BrainExe\Core\DependencyInjection\CompilerPass\EventCompilerPass

Complexity

Total Complexity

11

Size/Duplication

Total Lines	75
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

83.33%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	process()	0	4	1
A	getEvents()	0	13	3
A	getParameters()	0	9	2
B	handleEvent()	0	24	5

<?php

namespace BrainExe\Core\DependencyInjection\CompilerPass;

use BrainExe\Core\Annotations\CompilerPass;
use BrainExe\Core\EventDispatcher\AbstractEvent;
use BrainExe\Core\Traits\FileCacheTrait;
use Exception;
use ReflectionClass;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;

/**
 * @CompilerPass
 */
class EventCompilerPass implements CompilerPassInterface
{
    use FileCacheTrait;

    /**
     * {@inheritdoc}
     */
    public function process(ContainerBuilder $container)
    {
        $this->dumpVariableToCache('events', $this->getEvents());
    }

    /**
     * @return array
     * @throws Exception
     */
    private function getEvents()
    {
        $events = [];
        foreach (get_declared_classes() as $class) {
            $reflection = new ReflectionClass($class);

            if ($reflection->isSubclassOf(AbstractEvent::class)) {
                $this->handleEvent($reflection, $events, $class);
            }
        }

        return $events;
    }

    /**
     * @param ReflectionClass $reflection
     * @param $events
     * @param string $class
     * @throws Exception
     */
    private function handleEvent(ReflectionClass $reflection, array &$events, string $class)
    {
        foreach (array_values($reflection->getConstants()) as $constant) {
            if (strlen($constant) < 3 || strpos($constant, '.') === false) {
                continue;
            }

            if (isset($events[$constant])) {
                throw new Exception(sprintf(
                    'Event "%s" was already defined in "%s". (%s)',
                    $constant,
                    $events[$constant],
                    $class
                ));
            }

            $parameters = $this->getParameters($reflection);

            $events[$constant] = [
                'class'      => $class,
                'parameters' => $parameters
            ];
        }
    }

    /**
     * @param ReflectionClass $reflection
     * @return array
     */
    private function getParameters(ReflectionClass $reflection)
    {
        $parameters = [];
        foreach ($reflection->getConstructor()->getParameters() as $parameter) {
            $parameters[] = $parameter->getName();
        }

        return $parameters;
    }
}