Happyr\SimpleBusBundle\DependencyInjection\CompilerPass\CompilerPasses

Complexity

Total Complexity

32

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

59.14%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	process()	0	7	1
C	removeCommandHandlerDuplicates()	0	32	7
C	handleEventSubscriberDuplicates()	0	41	11
C	processMessageHandlers()	0	35	8
B	replaceSimpleBusPublisher()	0	33	3
A	hasDoctrine()	0	5	2

<?php

namespace Happyr\SimpleBusBundle\DependencyInjection\CompilerPass;

use Happyr\SimpleBusBundle\Message\Publisher\DirectPublisher;
use Happyr\SimpleBusBundle\Message\Publisher\RabbitMQPublisher;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Reference;

/**
 * @author Tobias Nyholm
 */
class CompilerPasses implements CompilerPassInterface
{
    public function process(ContainerBuilder $container)
    {
        $this->removeCommandHandlerDuplicates($container);
        $this->handleEventSubscriberDuplicates($container);
        $this->processMessageHandlers($container);
        $this->replaceSimpleBusPublisher($container);
    }

    /**
     * If we find to command handler services that are registered on the same command, make sure we remove the one with '.auto' on the end.
     *
     * @param ContainerBuilder $container
     */
    private function removeCommandHandlerDuplicates(ContainerBuilder $container)
    {
        $taggedServices = array_merge($container->findTaggedServiceIds('command_handler'), $container->findTaggedServiceIds('asynchronous_command_handler'));

        $commands = [];

        foreach ($taggedServices as $id => $tags) {
            foreach ($tags as $tag) {
                if (isset($commands[$tag['handles']])) {
                    // Find the one that ends with '.auto'
                    $removeServiceId = null;

                    if ('.auto' === substr($id, -5)) {
                        $removeServiceId = $id;
                    }

                    if ('.auto' === substr($commands[$tag['handles']], -5)) {
                        $removeServiceId = $commands[$tag['handles']];
                        $commands[$tag['handles']] = $id;
                    }

                    if (null !== $removeServiceId) {
                        // Remove the definition
                        $container->removeDefinition($removeServiceId);

                        continue;
                    }
                }
                $commands[$tag['handles']] = $id;
            }
        }
    }

    /**
     * @param ContainerBuilder $container
     */
    private function handleEventSubscriberDuplicates(ContainerBuilder $container)
    {
        $taggedServices = array_merge($container->findTaggedServiceIds('event_subscriber'), $container->findTaggedServiceIds('asynchronous_event_subscriber'));

        // Keys are event class names
        $events = [];

        foreach ($taggedServices as $id => $tags) {
            foreach ($tags as $tag) {
                if (isset($tag['subscribes_to'])) {
                    $events[$tag['subscribes_to']][] = $id;
                }
            }
        }

        foreach ($events as $eventClass => $subscribersIds) {
            if (count($subscribersIds) <= 1) {
                continue;
            }

            // Get services
            $subscriberClassNames = [];
            foreach ($subscribersIds as $subscribersId) {
                $service = $container->getDefinition($subscribersId);
                $subscriberClassNames[$service->getClass()][] = $subscribersId;
            }

            foreach ($subscriberClassNames as $className => $services) {
                if (count($services) <= 1) {
                    continue;
                }

                // IF we have multiple services registed to the same event subscriber, remove the auto added ones.
                foreach ($services as $serviceId) {
                    if ('.auto' === substr($serviceId, -5)) {
                        $container->removeDefinition($serviceId);
                    }
                }
            }
        }
    }

    /**
     * @param ContainerBuilder $container
     */
    private function processMessageHandlers(ContainerBuilder $container)
    {
        $taggedServices = array_merge(
            $container->findTaggedServiceIds('command_handler'),
            $container->findTaggedServiceIds('event_subscriber'),
            $container->findTaggedServiceIds('asynchronous_command_handler'),
            $container->findTaggedServiceIds('asynchronous_event_subscriber')
        );
        $doctrine = $this->hasDoctrine($container);

        foreach ($taggedServices as $id => $tags) {
            $def = $container->findDefinition($id);
            $class = $def->getClass();

            if (method_exists($class, 'setEventRecorder')) {
                $def->addMethodCall('setEventRecorder', [new Reference('event_recorder')]);
            }

            if (method_exists($class, 'setCommandBus')) {
                $def->addMethodCall('setCommandBus', [new Reference('command_bus')]);
            }

            if (method_exists($class, 'setEventBus')) {
                $def->addMethodCall('setEventBus', [new Reference('event_bus')]);
            }

            if ($doctrine && method_exists($class, 'setEntityManager')) {
                $def->addMethodCall('setEntityManager', [new Reference('doctrine.orm.entity_manager')]);
            }

            if (in_array('Psr\Log\LoggerAwareInterface', class_implements($class))) {
                $def->addMethodCall('setLogger', [new Reference('logger', ContainerInterface::NULL_ON_INVALID_REFERENCE)]);
            }
        }
    }

    /**
     * @param ContainerBuilder $container
     */
    private function replaceSimpleBusPublisher(ContainerBuilder $container)
    {
        if (!$container->has('simple_bus.rabbit_mq_bundle_bridge.event_publisher')) {
            return;
        }

        if (!$container->getParameter('happyr.simplebus.direct_publisher')) {
            $container->getDefinition('simple_bus.rabbit_mq_bundle_bridge.event_publisher')
                ->setClass(RabbitMQPublisher::class)
                ->setLazy(true);
            $container->getDefinition('simple_bus.rabbit_mq_bundle_bridge.command_publisher')
                ->setClass(RabbitMQPublisher::class)
                ->setLazy(true);
        } else {
            $container->getDefinition('simple_bus.rabbit_mq_bundle_bridge.event_publisher')
                ->setClass(DirectPublisher::class)
                ->setLazy(true)
                ->setArguments([
                    new Reference('happyr.mq2php.consumer_wrapper'),
                    new Reference('happyr.mq2php.message_serializer'),
                    $container->getParameter('happyr.mq2php.event_queue_name'),
                ]);

            $container->getDefinition('simple_bus.rabbit_mq_bundle_bridge.command_publisher')
                ->setClass(DirectPublisher::class)
                ->setLazy(true)
                ->setArguments([
                    new Reference('happyr.mq2php.consumer_wrapper'),
                    new Reference('happyr.mq2php.message_serializer'),
                    $container->getParameter('happyr.mq2php.command_queue_name'),
                ]);
        }
    }

    /**
     * @param ContainerBuilder $container
     *
     * @return bool
     */
    private function hasDoctrine(ContainerBuilder $container)
    {
        return $container->hasDefinition('doctrine.orm.entity_manager') ||
            $container->hasAlias('doctrine.orm.entity_manager');
    }
}