TomPHP\ConfigServiceProvider\Pimple\Configurator

Complexity

Total Complexity

12

Size/Duplication

Total Lines	73
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	4

Importance

Changes	6
Bugs	0	Features	2

6 Methods

Rating	Name	Duplication	Size	Complexity
A	setContainer()	0	4	1
A	addApplicationConfig()	0	10	3
A	addServiceConfig()	0	6	2
A	addInflectorConfig()	0	4	1
A	addServiceToContainer()	0	20	3
A	resolveArguments()	0	13	2

<?php

namespace TomPHP\ConfigServiceProvider\Pimple;

use Pimple\Container;
use ReflectionClass;
use TomPHP\ConfigServiceProvider\ApplicationConfig;
use TomPHP\ConfigServiceProvider\Configurator as ConfiguratorInterface;
use TomPHP\ConfigServiceProvider\Exception\UnsupportedFeatureException;
use TomPHP\ConfigServiceProvider\InflectorConfig;
use TomPHP\ConfigServiceProvider\ServiceConfig;
use TomPHP\ConfigServiceProvider\ServiceDefinition;

final class Configurator implements ConfiguratorInterface
{
    /**
     * @var Container
     */
    private $container;

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

    public function addApplicationConfig(ApplicationConfig $config, $prefix = 'config')
    {
        if (!empty($prefix)) {
            $prefix .= $config->getSeparator();
        }

        foreach ($config as $key => $value) {
            $this->container[$prefix . $key] = $value;
        }
    }

    public function addServiceConfig(ServiceConfig $config)
    {
        foreach ($config as $definition) {
            $this->addServiceToContainer($definition);
        }
    }

    public function addInflectorConfig(InflectorConfig $config)
    {
        throw UnsupportedFeatureException::forInflectors('Pimple');
    }

    private function addServiceToContainer(ServiceDefinition $definition)
    {
        $factory = function () use ($definition) {
            $reflection = new ReflectionClass($definition->getClass());

            $instance = $reflection->newInstanceArgs($this->resolveArguments($definition->getArguments()));

            foreach ($definition->getMethods() as $name => $args) {
                call_user_func_array([$instance, $name], $this->resolveArguments($args));
            }

            return $instance;
        };

        if (!$definition->isSingleton()) {
            $factory = $this->container->factory($factory);
        }

        $this->container[$definition->getName()] = $factory;
    }

    private function resolveArguments(array $arguments)
    {
        return array_map(
            function ($argument) {
                if (isset($this->container[$argument])) {
                    return $this->container[$argument];
                }

                return $argument;
            },
            $arguments
        );
    }
}