CapMousse\ReactRestify\Routing\Router

Complexity

Total Complexity

17

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	addRoutes()	0	12	2
A	addRoute()	0	4	1
A	addGroup()	0	6	1
A	addMiddleware()	0	13	1
A	launch()	0	22	3
B	matchRoutes()	0	39	6
A	runStack()	0	9	1

<?php

namespace CapMousse\ReactRestify\Routing;

use CapMousse\ReactRestify\Evenement\EventEmitter;
use CapMousse\ReactRestify\Http\Request;
use CapMousse\ReactRestify\Http\Response;
use CapMousse\ReactRestify\Traits\WaterfallTrait;
use CapMousse\ReactRestify\Container\Container;

class Router extends EventEmitter
{
    use WaterfallTrait;
    /**
     * The current routes list
     * @var array
     */
    public $routes = [];

    /**
     * @var array
     */
    private $middlewares = [];

    /**
     * The current asked uri
     * @var string|boolean
     */
    private $uri = false;

    /**
     * Create a new routing element
     *
     * @param array $routes a route array
     *
     * @throws \InvalidArgumentException
     */
    public function __construct($routes = [])
    {
        if (!is_array($routes)) {
            throw new \InvalidArgumentException("Routes must be an array");
        }

        $this->addRoutes($routes);
    }

    /**
     * Add routes
     *
     * @param array $routes a route array
     *
     * @throws \InvalidArgumentException
     * @return Void
     */
    public function addRoutes($routes)
    {
        if (!is_array($routes)) {
            throw new \InvalidArgumentException("Routes must be an array");
        }

        $routes = array_filter($routes, function ($route) {
            return is_a('Route', $route);
        });

        $this->routes = array_merge($this->routes, $routes);
    }

    /**
     * Add a new route
     *
     * @param String   $method   type of route
     * @param String   $route    uri to catch
     * @param Callable $callback
     */
    public function addRoute($method, $route, $callback)
    {
        return $this->routes[] = new Route(strtoupper($method), $route, $callback);
    }

    /**
     * Create a new group of routes
     *
     * @param String $prefix prefix of thes routes
     *
     * @return \CapMousse\ReactRestify\Routing\Group
     */
    public function addGroup($prefix, $callback)
    {
        $group = new Routes($this, $prefix, $callback);

        return $group;
    }

    /**
     * Add a middleware
     * @param string|Callable $callback
     */
    public function addMiddleware($callback)
    {
        $this->middlewares[] = function (Callable $next, Request $request, Response $response) use ($callback) {
            $container = Container::getInstance();
            $parameters = array_merge([
                "request"   => $request,
                "response"  => $response,
                "next"      => $next
            ], $request->getData());

            $container->call($callback, $parameters);
        };
    }

    /**
     * Launch the route parsing
     *
     * @param \React\Http\Request     $request
     * @param \React\Restify\Response $response
     *
     * @throws \RuntimeException
     * @return Void
     */
    public function launch(Request $request, Response $response)
    {
        if (count($this->routes) === 0) {
            throw new \RuntimeException("No routes defined");
        }

        $this->uri = $request->httpRequest->getPath();

        if ($this->uri = null) {
            $this->uri = "/";
        }

        $request->on('end', function () use (&$request, &$response) {
            $this->matchRoutes($request, $response);  
        });

        $request->on('error', function ($error) use (&$request, &$response) {
            $this->emit('error', [$request, $response, $error]);
        });

        $request->parseData();
    }

    /**
     * Try to match the current uri with all routes
     *
     *
     * @param \React\Http\Request     $request
     * @param \React\Restify\Response $response
     *
     * @throws \RuntimeException
     * @return Void
     */
    private function matchRoutes(Request $request, Response $response)
    {
        $stack = [];
        $badMethod = false;

        foreach ($this->routes as $route) {
            if (!$route->match($request->httpRequest->getPath())) {
                continue;
            }

            if ($route->method != strtoupper($request->httpRequest->getMethod())) {
                $badMethod = true;
                continue;
            }

            $methodArgs = $route->getArgs($request->httpRequest->getPath());
            $request->setData($methodArgs);

            $route->on('error', function () {
                $this->emit('error', func_get_args());
            });

            $stack[] = function (...$params) use ($route) {
                $route->run(...$params);
            };
        }

        if (count($stack)) {
            $this->runStack($stack, $request, $response);
            return;
        }

        if ($badMethod) {
            $this->emit('MethodNotAllowed', array(&$request, &$response));
            return;
        }

        $this->emit('NotFound', array($request, $response));
    }

    protected function runStack(array $stack, Request $request, Response $response)
    {
        $stack[] = function () use ($response) {
            $response->end();
        };

        $finalStack = array_merge($this->middlewares, $stack);
        $this->waterfall($finalStack, [$request, $response]);
    }
}