Borobudur\DependencyInjection\ArrayServiceLoader

Complexity

Total Complexity

37

Size/Duplication

Total Lines	215
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	6
Bugs	0	Features	3

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	load()	0	20	7
A	buildDefinitionFromArray()	0	13	3
A	addDefinitionCallsFromArray()	0	13	4
A	addDefinitionTagsFromArray()	0	15	4
A	normalizeParameters()	0	14	3
B	computeValue()	0	16	5
A	isValidArrayParameters()	0	4	2
A	getArrayServiceAbstract()	0	4	2
A	isArrayServiceHasCalls()	0	4	2
A	isArrayServiceHasTags()	0	4	2
A	isArrayService()	0	4	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;

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

/**
 * @author      Iqbal Maulana <iq.bluejack@gmail.com>
 * @created     8/16/15
 */
class ArrayServiceLoader
{
    /**
     * @var ContainerBuilder
     */
    private $container;

    /**
     * @param ContainerBuilder $container
     */
    public function __construct(ContainerBuilder $container)
    {
        $this->container = $container;
    }

    /**
     * Load service from array.
     *
     * @param array $services
     */
    public function load(array $services)
    {
        foreach ($services as $id => $service) {
            if ('services' === $id) {
                $this->load($service);
                continue;
            }

            if (is_int($id) || !$this->isArrayService($service)) {
                continue;
            }

            $this->container->setDefinition($id, $this->buildDefinitionFromArray($id, $service));

            // Build service immediately when eager is true.
            if (isset($service['eager']) && true === $service['eager']) {
                $this->container->get($id);
            }
        }
    }

    /**
     * Build definition from array.
     *
     * @param string $id
     * @param array  $service
     *
     * @return Definition
     */
    private function buildDefinitionFromArray($id, array $service)
    {
        $definition = new Definition($service['class'], $this->normalizeParameters($service, 'arguments'));
        $definition->setAbstract($this->getArrayServiceAbstract($service));
        $this->addDefinitionTagsFromArray($definition, $id, $service);
        $this->addDefinitionCallsFromArray($definition, $service);

        if (isset($service['share']) && true === $service['share']) {
            $definition->share();
        }

        return $definition;
    }

    /**
     * Add method calls on definition.
     *
     * @param Definition $definition
     * @param array      $service
     */
    private function addDefinitionCallsFromArray(Definition &$definition, array $service)
    {
        if ($this->isArrayServiceHasCalls($service)) {
            foreach ($service['calls'] as $method => $parameters) {
                if (is_int($method)) {
                    $definition->addMethodCall($parameters);
                    continue;
                }

                $definition->addMethodCall($method, $this->normalizeParameters($service['calls'], $method));
            }
        }
    }

    /**
     * Add tags on definition.
     *
     * @param Definition $definition
     * @param string     $id
     * @param array      $service
     */
    private function addDefinitionTagsFromArray(Definition &$definition, $id, array $service)
    {
        if ($this->isArrayServiceHasTags($service)) {
            foreach ($service['tags'] as $tag) {
                if (!isset($tag['name'])) {
                    throw new InvalidArgumentException(sprintf('Undefined tag name on service "%s"', $id));
                }

                $name = $tag['name'];
                unset ($tag['name']);

                $definition->addTag($name, $tag);
            }
        }
    }

    /**
     * Normalize array service parameters.
     *
     * @param array  $service
     * @param string $index
     *
     * @return array
     */
    private function normalizeParameters(array $service, $index)
    {
        if (!$this->isValidArrayParameters($service, $index)) {
            return array();
        }

        $resolver = $this->container->getParameterBag()->getResolver();
        $normalized = array();
        foreach ($service[$index] as $index => $value) {
            $normalized[$index] = $this->computeValue($value, $resolver);
        }

        return $resolver->resolveValue($normalized);
    }

    /**
     * Compute value.
     *
     * @param string   $value
     * @param Resolver $resolver
     *
     * @return array|Reference|mixed
     */
    private function computeValue($value, Resolver $resolver)
    {
        if (is_string($value)) {
            if (0 === strrpos($value, '@')) {
                $value = new Reference(substr($value, 1));
            } else {
                $value = $resolver->unescapeValue($value);
            }
        } elseif (is_array($value)) {
            foreach ($value as $index => $val) {
                $value[$index] = $this->computeValue($val, $resolver);
            }
        }

        return $value;
    }

    /**
     * Check if array service parameters is valid.
     *
     * @param array  $service
     * @param string $index
     *
     * @return bool
     */
    private function isValidArrayParameters(array $service, $index)
    {
        return isset($service[$index]) && is_array($service[$index]);
    }

    /**
     * Get abstract on array service.
     *
     * @param array $service
     *
     * @return string|null
     */
    private function getArrayServiceAbstract(array $service)
    {
        return isset($service['abstract']) ? $service['abstract'] : null;
    }

    /**
     * Check if array service has calls.
     *
     * @param array $service
     *
     * @return bool
     */
    private function isArrayServiceHasCalls(array $service)
    {
        return isset($service['calls']) && is_array($service['calls']);
    }

    /**
     * Check if array service has tags.
     *
     * @param array $service
     *
     * @return bool
     */
    private function isArrayServiceHasTags(array $service)
    {
        return isset($service['tags']) && is_array($service['tags']);
    }

    /**
     * Check if array is service.
     *
     * @param mixed $service
     *
     * @return bool
     */
    private function isArrayService($service)
    {
        return is_array($service) && isset($service['class']);
    }
}