GBProd\ElasticaBundle\DependencyInjection\ElasticaExtension

Complexity

Total Complexity

17

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

98.39%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	15	1
A	loadLogger()	0	12	2
A	createLoggerReference()	0	11	2
D	loadClients()	0	28	10
A	loadClient()	0	14	1
A	createClientId()	0	7	1

<?php

namespace GBProd\ElasticaBundle\DependencyInjection;

use Elastica\Client;
use GBProd\ElasticaBundle\Logger\ElasticaLogger;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
use Symfony\Component\DependencyInjection\Exception\LogicException;
use Symfony\Component\DependencyInjection\Loader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

/**
 * Extension class for ElasticaExtension
 *
 * @author gbprod <contact@gb-prod.fr>
 */
class ElasticaExtension extends Extension
{
    const CLIENT_ID_TEMPLATE = 'elastica.%s_client';

    /**
     * {@inheritdoc}
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configuration = new Configuration();
        $config = $this->processConfiguration($configuration, $configs);

        $loader = new Loader\YamlFileLoader(
            $container,
            new FileLocator(__DIR__ . '/../Resources/config')
        );

        $loader->load('services.yml');

        $this->loadLogger($config, $container);
        $this->loadClients($config, $container);
    }

    private function loadLogger(array $config, ContainerBuilder $container)
    {
        $definition = $container
            ->register('elastica.logger', ElasticaLogger::class)
            ->addArgument($this->createLoggerReference($config))
            ->addArgument('%kernel.debug%')
            ->setPublic(true);

        if ('logger' === $config['logger']) {
            $definition->addTag('monolog.logger', ['channel' => 'elastica']);
        }
    }

    private function createLoggerReference(array $config)
    {
        if (null !== $config['logger']) {
            return new Reference(
                $config['logger'],
                ContainerInterface::IGNORE_ON_INVALID_REFERENCE
            );
        }

        return null;
    }

    /**
     * @param array $config
     * @param ContainerBuilder $container
     * @throws \Symfony\Component\DependencyInjection\Exception\LogicException
     * @throws InvalidArgumentException
     */
    private function loadClients(array $config, ContainerBuilder $container)
    {
        foreach ($config['clients'] as $clientName => $clientConfig) {
            $this->loadClient($clientName, $clientConfig, $container);
        }
        // If container have support for services auto-wiring
        // and we have client to define as default - create service alias for auto-wiring
        if (!method_exists($container, 'autowire')) {
            return;
        }
        $defaultClient = $config['default_client'];
        if ($defaultClient === false) {
            // Default client definition is not allowed
            return;
        }
        if ($defaultClient === null && !empty($config['clients'])) {
            $defaultClient = key($config['clients']);
        }
        if ($defaultClient !== null && !array_key_exists($defaultClient, $config['clients'])) {
            throw new InvalidArgumentException(sprintf('Invalid default Elasticsearch client is defined: %s', $defaultClient));

This line exceeds maximum limit of 120 characters; contains 127 characters

        }
        if ($container->hasDefinition(Client::class)) {
            throw new LogicException('Default Elasticsearch client registration is requested, but client service is already defined in container');

This line exceeds maximum limit of 120 characters; contains 147 characters

        }
        if ($defaultClient !== null) {
            $container->setAlias(Client::class, $this->createClientId($defaultClient));
        }
    }

    private function loadClient($clientName, array $clientConfig, ContainerBuilder $container)
    {
        $container
            ->register($this->createClientId($clientName), Client::class)
            ->addArgument($clientConfig)
            ->addMethodCall('setLogger', [
                new Reference('elastica.logger')
            ])
            ->addMethodCall('setConfigValue', [
                'log',
                $container->getParameter('kernel.debug')
            ])
            ->setPublic(true);
    }

    private function createClientId($clientName)
    {
        return sprintf(
            self::CLIENT_ID_TEMPLATE,
            $clientName
        );
    }
}