BrainExe\Core\DependencyInjection\CompilerPass\ControllerCompilerPass

Complexity

Total Complexity

9

Size/Duplication

Total Lines	85
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	5

Test Coverage

Coverage

97.14%

Importance

Changes	10
Bugs	0	Features	3

3 Methods

Rating	Name	Duplication	Size	Complexity
A	dumpMatcher()	0	19	2
B	process()	0	30	5
A	createRoute()	0	17	2

<?php

namespace BrainExe\Core\DependencyInjection\CompilerPass;

use BrainExe\Core\Annotations\CompilerPass;
use BrainExe\Core\Annotations\Route as RouteAnnotation;
use BrainExe\Core\Application\SerializedRouteCollection;
use Exception;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\Routing\Generator\Dumper\PhpGeneratorDumper;
use Symfony\Component\Routing\Matcher\Dumper\PhpMatcherDumper;
use Symfony\Component\Routing\Route;

/**
 * @CompilerPass(priority=5)
 */
class ControllerCompilerPass implements CompilerPassInterface
{
    const CONTROLLER_TAG = 'controller';
    const ROUTE_TAG      = 'route';

    /**
     * {@inheritdoc}
     */
    public function process(ContainerBuilder $container)
    {
        $coreCollector = $container->getDefinition('Core.RouteCollection');
        $controllers   = $container->findTaggedServiceIds(self::ROUTE_TAG);

        $serialized = [];
        foreach ($controllers as $controllerId => $tag) {
            foreach ($tag as $routeRaw) {
                /** @var RouteAnnotation $route */
                $route = $routeRaw[0];

                $name = $route->getName();
                if (!$name) {
                    throw new Exception(sprintf('"name" is missing for @Route(%s)', $controllerId));
                }
                if ($route->isCsrf()) {
                    $route->setOptions(['csrf' => true]);
                }

                $serialized[$name] = serialize($this->createRoute($route));
            }

            $controller = $container->getDefinition($controllerId);
            $controller->clearTag(self::ROUTE_TAG);
        }

        $coreCollector->addArgument($serialized);

        $this->dumpMatcher($container);
    }

    /**
     * @param RouteAnnotation $route
     * @return Route
     */
    private function createRoute(RouteAnnotation $route)
    {
        if ($route->isCsrf()) {
            $route->setOptions(['csrf' => true]);
        }

        return new Route(
            $route->getPath(),
            $route->getDefaults(),
            $route->getRequirements(),
            $route->getOptions(),
            $route->getHost(),
            $route->getSchemes(),
            $route->getMethods(),
            $route->getCondition()
        );
    }

    /**
     * @param ContainerBuilder $container
     * @codeCoverageIgnore
     */
    protected function dumpMatcher(ContainerBuilder $container)
    {
        if (!is_dir(ROOT . 'cache')) {
            return;
        }

        /** @var SerializedRouteCollection $routerCollection */
        $routerCollection = $container->get('Core.RouteCollection');

        $routerFile  = sprintf('%scache/router_matcher.php', ROOT);
        $routeDumper = new PhpMatcherDumper($routerCollection);
        $content     = $routeDumper->dump();
        file_put_contents($routerFile, $content);

        $routerFile  = sprintf('%scache/router_generator.php', ROOT);
        $routeDumper = new PhpGeneratorDumper($routerCollection);
        $content     = $routeDumper->dump();
        file_put_contents($routerFile, $content);
    }
}