Innmind\Rest\ServerBundle\Routing\RouteLoader

Complexity

Total Complexity

11

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

97.96%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	load()	0	31	3
A	supports()	0	4	1
A	buildDirectoryRoutes()	0	15	1
A	__construct()	0	14	3
B	buildResourceRoutes()	0	24	3

<?php
declare(strict_types = 1);

namespace Innmind\Rest\ServerBundle\Routing;

use Innmind\Rest\ServerBundle\Exception\{
    InvalidArgumentException,
    RouteLoaderLoadedMultipleTimesException
};
use Innmind\Rest\Server\{
    Definition\Directory,
    Definition\HttpResource,
    Action
};
use Innmind\Http\Message\MethodInterface;
use Innmind\Immutable\{
    MapInterface,
    StringPrimitive as Str
};
use Symfony\Component\{
    Config\Loader\Loader,
    Routing\RouteCollection,
    Routing\Route
};

final class RouteLoader extends Loader
{
    private $directories;
    private $routeFactory;
    private $imported = false;

    public function __construct(
        MapInterface $directories,
        RouteFactory $routeFactory
    ) {
        if (
            (string) $directories->keyType() !== 'string' ||
            (string) $directories->valueType() !== Directory::class
        ) {
            throw new InvalidArgumentException;
        }

        $this->directories = $directories;
        $this->routeFactory = $routeFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function load($resource, $type = null)
    {
        if ($this->imported === true) {
            throw new RouteLoaderLoadedMultipleTimesException;
        }

        $routes = new RouteCollection;

        foreach ($this->directories as $directory) {
            $routes->addCollection(
                $this->buildDirectoryRoutes($directory)
            );
        }

        $routes->add(
            'innmind_rest_server_capabilities',
            new Route(
                '/*',
                ['_controller' => 'innmind_rest_server.controller.capabilities:capabilitiesAction'],
                [],
                [],
                '',
                [],
                [MethodInterface::OPTIONS]
            )
        );

        $this->imported = true;

        return $routes;
    }

    /**
     * {@inheritdoc}
     */
    public function supports($resource, $type = null)
    {
        return $type === 'innmind_rest';
    }

    private function buildDirectoryRoutes(Directory $directory): RouteCollection
    {
        return $directory
            ->flatten()
            ->reduce(
                new RouteCollection,
                function(RouteCollection $routes, string $name, HttpResource $definition) {
                    $routes->addCollection(
                        $this->buildResourceRoutes($name, $definition)
                    );

                    return $routes;
                }
            );
    }

    private function buildResourceRoutes(
        string $name,
        HttpResource $definition
    ): RouteCollection {
        return Action::all()
            ->reduce(
                new RouteCollection,
                function(RouteCollection $carry, string $action) use ($name, $definition) {
                    if (
                        $definition->options()->contains('actions') &&
                        !in_array($action, $definition->options()->get('actions'))
                    ) {
                        return $carry;
                    }

                    $carry->add(
                        $this->routeFactory->makeName($name, new Action($action)),
                        $this->routeFactory->makeRoute($name, new Action($action))
                    );

                    return $carry;
                }
            );
    }
}