Thruster\Component\HttpRouter\Router

Complexity

Total Complexity

17

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

100%

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
B	buildRoutes()	0	25	5
B	handleRequest()	0	22	4
A	getDispatcher()	0	12	2
A	setDispatcher()	0	6	1
A	getRouteCollector()	0	12	2
A	setRouteCollector()	0	6	1
A	getRouteData()	0	6	1

<?php

namespace Thruster\Component\HttpRouter;

use FastRoute\BadRouteException;
use FastRoute\Dispatcher;
use FastRoute\RouteParser;
use FastRoute\DataGenerator;
use FastRoute\RouteCollector;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Thruster\Component\HttpRouter\Exception\InvalidRouteOptionsException;
use Thruster\Component\HttpRouter\Exception\RouteNotFoundException;
use Thruster\Component\HttpRouter\Exception\RouteMethodNotAllowedException;

/**
 * Class Router
 *
 * @package Thruster\Component\HttpRouter
 * @author  Aurimas Niekis <aurimas@niekis.lt>
 */
class Router
{
    /**
     * @var array
     */
    protected $options;

    /**
     * @var array
     */
    protected $routes;

    /**
     * @var RouteableInterface
     */
    protected $handler;

    /**
     * @var RouteCollector
     */
    protected $routeCollector;

    /**
     * @var Dispatcher
     */
    protected $dispatcher;

    public function __construct(RouteableInterface $handler, array $options = [])
    {
        $options += [
            'route_parser' => 'FastRoute\\RouteParser\\Std',
            'data_generator' => 'FastRoute\\DataGenerator\\GroupCountBased',
            'dispatcher' => 'FastRoute\\Dispatcher\\GroupCountBased',
            'route_collector' => 'FastRoute\\RouteCollector',
        ];

        $this->routes = [];
        $this->handler = $handler;
        $this->options = $options;
    }

    public function buildRoutes()
    {
        $routeCollection = $this->getRouteCollector();

        foreach ($this->handler->getRoutes() as $name => $options) {
            if (count($options) < 3) {
                throw new InvalidRouteOptionsException($name);
            }

            $handler = array_pop($options);
            if (is_string($handler)) {
                $handler = [$this->handler, $handler];
            }

            $this->routes[$name] = $handler;

            $route = array_pop($options);

            try {
                $routeCollection->addRoute($options, $route, $name);
            } catch (BadRouteException $e) {
                throw new InvalidRouteOptionsException($name, $e);
            }
        }
    }

    /**
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     * @throws RouteMethodNotAllowedException
     * @throws RouteNotFoundException
     */
    public function handleRequest(ServerRequestInterface $request) : ResponseInterface
    {
        $dispatcher = $this->getDispatcher();
        $uri = $request->getUri();

        $route = $dispatcher->dispatch($request->getMethod(), $uri->getPath());

        switch ($route[0]) {
            case Dispatcher::NOT_FOUND:
                throw new RouteNotFoundException($request);
            case Dispatcher::METHOD_NOT_ALLOWED:
                throw new RouteMethodNotAllowedException($request, $route[1]);
            case Dispatcher::FOUND:
                $request = $request
                    ->withAttribute('route_name', $route[1])
                    ->withAttribute('route_params', $route[2]);

                return call_user_func($this->routes[$route[1]], $request);
        }

        throw new \LogicException('Should not reach this point');
    }

    /**
     * @return Dispatcher
     */
    public function getDispatcher() : Dispatcher
    {
        if ($this->dispatcher) {
            return $this->dispatcher;
        }

        $this->dispatcher = new $this->options['dispatcher'](
            $this->getRouteData()
        );

        return $this->dispatcher;
    }

    /**
     * @param Dispatcher $dispatcher
     *
     * @return $this
     */
    public function setDispatcher(Dispatcher $dispatcher) : self
    {
        $this->dispatcher = $dispatcher;

        return $this;
    }

    /**
     * @return RouteCollector
     */
    public function getRouteCollector() : RouteCollector
    {
        if ($this->routeCollector) {
            return $this->routeCollector;
        }

        $this->routeCollector = new $this->options['route_collector'](
            new $this->options['route_parser'](), new $this->options['data_generator']()
        );

        return $this->routeCollector;
    }

    /**
     * @param RouteCollector $routeCollector
     *
     * @return $this
     */
    public function setRouteCollector(RouteCollector $routeCollector) : self
    {
        $this->routeCollector = $routeCollector;

        return $this;
    }

    /**
     * @return array
     */
    public function getRouteData() : array
    {
        $this->buildRoutes();

        return $this->getRouteCollector()->getData();
    }
}