Ekino\Drupal\Debug\Action\WatchModulesHooksImplementations\WatchModulesHooksImplementationsAction

Complexity

Total Complexity

5

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

68.57%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getSubscribedEvents()	0	4	1
A	__construct()	0	3	1
A	process()	0	25	1
A	setResources()	0	16	1
A	getOptionsClass()	0	3	1

<?php

declare(strict_types=1);

/*
 * This file is part of the ekino Drupal Debug project.
 *
 * (c) ekino
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Ekino\Drupal\Debug\Action\WatchModulesHooksImplementations;

use Drupal\Core\Extension\ModuleHandler;
use Ekino\Drupal\Debug\Action\ActionWithOptionsInterface;
use Ekino\Drupal\Debug\Action\CompilerPassActionInterface;
use Ekino\Drupal\Debug\Action\EventSubscriberActionInterface;
use Ekino\Drupal\Debug\Action\ValidateContainerDefinitionTrait;
use Ekino\Drupal\Debug\Cache\Event\FileBackendEvents;
use Ekino\Drupal\Debug\Cache\FileBackend;
use Ekino\Drupal\Debug\Cache\FileCache;
use Ekino\Drupal\Debug\Kernel\Event\AfterAttachSyntheticEvent;
use Ekino\Drupal\Debug\Kernel\Event\DebugKernelEvents;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\HttpKernel\HttpKernelInterface;

class WatchModulesHooksImplementationsAction implements CompilerPassActionInterface, EventSubscriberActionInterface, ActionWithOptionsInterface
{
    use ValidateContainerDefinitionTrait;

    /**
     * @var string
     */
    private const RESOURCES_SERVICE_ID = 'ekino.drupal.debug.action.watch_modules_hooks_implementations.resources';

    /**
     * @var WatchModulesHooksImplementationsOptions
     */
    private $options;

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents(): array
    {
        return array(
            DebugKernelEvents::AFTER_ATTACH_SYNTHETIC => 'setResources',
        );
    }

    /**
     * @param WatchModulesHooksImplementationsOptions $options
     */
    public function __construct(WatchModulesHooksImplementationsOptions $options)
    {
        $this->options = $options;
    }

    /**
     * {@inheritdoc}
     */
    public function process(ContainerBuilder $container): void
    {
        $moduleHandlerDefinition = $this->validateContainerDefinitionClassIs($container, 'module_handler', ModuleHandler::class);

        $eventDispatcherDefinition = new Definition();
        $eventDispatcherDefinition->setSynthetic(true);
        $container->setDefinition('ekino.drupal.debug.event_dispatcher', $eventDispatcherDefinition);

        $this->validateContainerDefinitionClassImplements($container, 'kernel', HttpKernelInterface::class);

        $resourcesDefinition = new Definition();
        $resourcesDefinition->setSynthetic(true);
        $container->setDefinition(self::RESOURCES_SERVICE_ID, $resourcesDefinition);

        $fileBackendDefinition = new Definition(FileBackend::class, array(
            new Definition(FileCache::class, array(
                $this->options->getCacheFilePath(),
                new Reference(self::RESOURCES_SERVICE_ID),
            )),
        ));
        $fileBackendDefinition->addMethodCall('setEventDispatcher', array(
            new Reference('ekino.drupal.debug.event_dispatcher'),
        ));

        $moduleHandlerDefinition->replaceArgument(2, $fileBackendDefinition);
    }

    /**
     * @param AfterAttachSyntheticEvent $event
     */
    public function setResources(AfterAttachSyntheticEvent $event): void
    {
        $event->getContainer()->set(self::RESOURCES_SERVICE_ID, $this->options->getFilteredResourcesCollection($event->getEnabledModules(), $event->getEnabledThemes()));

        /** @var EventDispatcher $eventDispatcher */
        $eventDispatcher = $event->getContainer()->get('ekino.drupal.debug.event_dispatcher');
        /** @var ModuleHandler $moduleHandler */
        $moduleHandler = $event->getContainer()->get('module_handler');
        /** @var HttpKernelInterface $kernel */
        $kernel = $event->getContainer()->get('kernel');

        $eventDispatcher->addListener(
            FileBackendEvents::ON_CACHE_NOT_FRESH,
            new LoadNewModuleFile(
                $moduleHandler,
                $kernel
            )
        );
    }

    /**
     * {@inheritdoc}
     */
    public static function getOptionsClass(): string
    {
        return WatchModulesHooksImplementationsOptions::class;
    }
}