Spiechu\SymfonyCommonsBundle\DependencyInjection\SpiechuSymfonyCommonsExtension

Complexity

Total Complexity

12

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	processGetMethodOverride()	0	15	3
B	processResponseSchemaValidation()	0	22	4
A	clearListenerTags()	0	7	1
A	load()	0	13	2
A	addOrReplaceDefinitionArgument()	0	8	2

<?php

namespace Spiechu\SymfonyCommonsBundle\DependencyInjection;

use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
use Symfony\Component\DependencyInjection\Exception\OutOfBoundsException;
use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

class SpiechuSymfonyCommonsExtension extends Extension
{
    /**
     * {@inheritdoc}
     *
     * @throws OutOfBoundsException
     * @throws ServiceNotFoundException
     * @throws \Exception
     * @throws InvalidArgumentException
     */
    public function load(array $configs, ContainerBuilder $container): void
    {
        $processedConfig = $this->processConfiguration(new Configuration(), $configs);

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

        $this->processGetMethodOverride($loader, $container, $processedConfig['get_method_override']);
        $this->processResponseSchemaValidation($loader, $container, $processedConfig['response_schema_validation']);

        if ($container->getParameter('kernel.debug')) {
            $loader->load('debug_services.xml');
        }
    }

    protected function processGetMethodOverride(XmlFileLoader $loader, ContainerBuilder $container, array $options): void
    {
        if (!$options['enabled']) {
            return;
        }

        if ('spiechu_symfony_commons.event_listener.get_method_override_listener' === $options['listener_service_id']) {
            $loader->load('get_method_override_listener.xml');
        }

        $getMethodOverrideListenerDefinition = $container->getDefinition($options['listener_service_id']);

        $this->addOrReplaceDefinitionArgument($getMethodOverrideListenerDefinition, 0, $options['query_param_name']);
        $this->addOrReplaceDefinitionArgument($getMethodOverrideListenerDefinition, 1, $options['allow_methods_override']);
    }

    protected function processResponseSchemaValidation(XmlFileLoader $loader, ContainerBuilder $container, array $options): void
    {
        if (!$options['enabled']) {
            return;
        }

        $loader->load('response_schema_validation_listeners.xml');

        $this->addOrReplaceDefinitionArgument(
            $container->getDefinition('spiechu_symfony_commons.event_listener.response_schema_validator_listener'),
            1,
            $options['throw_exception_when_format_not_found']
        );

        if ('spiechu_symfony_commons.event_listener.failed_schema_check_listener' !== $options['failed_schema_check_listener_service_id']) {
            $this->clearListenerTags($container->getDefinition('spiechu_symfony_commons.event_listener.failed_schema_check_listener'));
        }

        if ($options['disable_json_check_schema_subscriber']) {
            $this->clearListenerTags($container->getDefinition('spiechu_symfony_commons.event_listener.json_check_schema_subscriber'));
        }
    }

    protected function addOrReplaceDefinitionArgument(Definition $definition, int $index, $value): void
    {
        if (array_key_exists($index, $definition->getArguments())) {
            $definition->replaceArgument($index, $value);
        } else {
            $definition->setArgument($index, $value);
        }
    }

    protected function clearListenerTags(Definition $definition): void
    {
        $definition->clearTag('kernel.event_subscriber');
        $definition->clearTag('kernel.event_listener');

        $definition->setPublic(false);
    }
}