Maikuro\DistributedConfigurationBundle\DependencyInjection\MaikuroDistributedConfigurationExtension

Complexity

Total Complexity

26

Size/Duplication

Total Lines	160
Duplicated Lines	5 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	8	1
B	loadStore()	0	20	5
C	loadRedisStore()	8	36	7
B	loadPredisStore()	0	37	6
A	loadJsonStore()	0	7	1
A	loadDbalStore()	0	12	2
B	loadStoreHandler()	0	22	4

<?php

/*
 * This file is part of the distributed-configuration-bundle package
 *
 * Copyright (c) 2016 Guillaume Cavana
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Feel free to edit as you please, and have fun.
 *
 * @author Guillaume Cavana <guillaume.cavana@gmail.com>
 */

namespace Maikuro\DistributedConfigurationBundle\DependencyInjection;

use Symfony\Component\Config\Definition\Processor;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

class MaikuroDistributedConfigurationExtension extends Extension
{
    /**
     * {@inheritdoc}
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $processor = new Processor();
        $configuration = new Configuration();
        $config = $processor->processConfiguration($configuration, $configs);

        $this->loadStoreHandler($container, $config);
    }

    /**
     * loadStoreHandler.
     *
     * @param ContainerBuilder $container
     * @param array            $config
     */
    private function loadStoreHandler(ContainerBuilder $container, array $config)
    {
        $storeHandlerDef = new Definition('Maikuro\DistributedConfigurationBundle\Handler\StoreHandler');
        $storeDef = $this->loadStore($container, $config['store']);
        if (null === $storeDef) {
            throw new InvalidArgumentException('No store found');
        }
        $storeHandlerDef->addArgument($storeDef);
        //Enabled caching
        if ($config['cache']['enabled']) {
            if (null === $config['cache']['service_id']) {
                throw new InvalidArgumentException(
                    'You need to install DoctrineCacheBundle and configure it to use cache feature'
                );
            }
            $cachingDecoratorDef = new Definition('Webmozart\KeyValueStore\Decorator\CachingDecorator',
                [$storeDef, new Reference($config['cache']['service_id'])]
            );
            $storeHandlerDef->replaceArgument(0, $cachingDecoratorDef);
        }
        $container->setDefinition('maikuro_distributed_configuration.store_handler', $storeHandlerDef);
    }

    private function loadStore(ContainerBuilder $container, array $config)
    {
        switch ($config['type']) {
            case 'redis':
                return $this->loadRedisStore($container, $config);
                break;

break is not strictly necessary here and could be removed.

            case 'predis':
                return $this->loadPredisStore($container, $config);
                break;

break is not strictly necessary here and could be removed.

            case 'dbal':
                return $this->loadDbalStore($container, $config);
                break;

break is not strictly necessary here and could be removed.

            case 'json':
                return $this->loadJsonStore($container, $config);
                break;

break is not strictly necessary here and could be removed.

            default:
                return;
                break;

break is not strictly necessary here and could be removed.

        }
    }

    private function loadRedisStore(ContainerBuilder $container, array $config)
    {
        $redisStoreDef = new Definition('Webmozart\KeyValueStore\PhpRedisStore');

        if (isset($config['store']['connection_id'])) {
            $redisStoreDef->addArgument(new Reference($config['connection_id']));
        } else {
            $host = $config['host'];
            $port = $config['port'];
            $connId = 'maikuro_distributed_configuration.redis.connection';
            $connDef = new Definition('Redis');
            $connParams = array($host, $port);
            if (isset($config['timeout'])) {
                $connParams[] = $config['timeout'];
            }
            $connMethod = 'connect';
            if (isset($config['persistent']) && $config['persistent']) {
                $connMethod = 'pconnect';
            }
            $connDef->setPublic(false);
            $connDef->addMethodCall($connMethod, $connParams);
            if (isset($config['password'])) {

This code seems to be duplicated across your project.

                $password = $config['password'];
                $connDef->addMethodCall('auth', array($password));
            }
            if (isset($config['database'])) {

This code seems to be duplicated across your project.

                $database = (int) $config['database'];
                $connDef->addMethodCall('select', array($database));
            }
            $container->setDefinition($connId, $connDef);

            $redisStoreDef->addArgument(new Reference($connId));
        }

        return $redisStoreDef;
    }

    private function loadPredisStore(ContainerBuilder $container, array $config)
    {
        $predisStoreDef = new Definition('Webmozart\KeyValueStore\PredisStore');

        if (isset($config['client_id'])) {
            $predisStoreDef->addArgument(new Reference($config['connection_id']));
        } else {
            $parameters = array(
                'scheme' => $config['scheme'],
                'host' => $config['host'],
                'port' => $config['port'],
            );
            if ($config['password']) {
                $parameters['password'] = $config['password'];
            }
            if ($config['timeout']) {
                $parameters['timeout'] = $config['timeout'];
            }
            if ($config['database']) {
                $parameters['database'] = $config['database'];
            }
            $options = null;
            if (isset($config['options'])) {
                $options = $config['options'];
            }
            $clientId = 'maikuro_distributed_configuration.predis.client';
            $clientDef = new Definition('Predis\Client');
            $clientDef->addArgument($parameters);
            $clientDef->addArgument($options);
            $clientDef->setPublic(false);
            $container->setDefinition($clientId, $clientDef);

            $predisStoreDef->addArgument(new Reference($clientId));
        }

        return $predisStoreDef;
    }

    private function loadJsonStore(ContainerBuilder $container, array $config)

The parameter $container is not used and could be removed.

    {
        $jsonStoreDef = new Definition('Webmozart\KeyValueStore\JsonFileStore');
        $jsonStoreDef->addArgument($config['json']['path']);

        return $jsonStoreDef;
    }

    private function loadDbalStore(ContainerBuilder $container, array $config)

The parameter $container is not used and could be removed.

    {
        $dbalStoreDef = new Definition('Webmozart\KeyValueStore\DbalStore');

        if (!isset($config['connection_id'])) {
            throw new InvalidArgumentException('No dbal connection configured');
        }

        $dbalStoreDef->addArgument(new Reference($config['connection_id']), $config['table_name']);

The call to Definition::addArgument() has too many arguments starting with $config['table_name'].

        return $dbalStoreDef;
    }
}