Philae\Middlewares\RouteDispatcher

Complexity

Total Complexity

7

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

80.65%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	dispatcherClass()	0	6	1
A	process()	0	12	1
B	dispatch()	0	31	4

<?php

namespace Philae\Middlewares;

use FastRoute\Dispatcher as FastRouteDispatcher;
use FastRoute\Dispatcher\GroupCountBased as GroupCountBasedDispatcher;
use FastRoute\RouteCollector;
use Interop\Http\ServerMiddleware\DelegateInterface;
use Middlewares\HttpErrorException;
use Middlewares\Utils\CallableResolver\CallableResolverInterface;
use Philae\DefaultServiceProvider;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class RouteDispatcher extends AbstractMiddleware
{
    /**
     * @var string Middleware attribute name
     */
    protected $attribute = 'request-handler';

    /**
     * @var FastRouteDispatcher FastRoute dispatcher
     */
    protected $dispatcherClass;

    /**
     * @param string $dispatcherClass
     */
    public function __construct(string $dispatcherClass = GroupCountBasedDispatcher::class)
    {
        $this->dispatcherClass = $dispatcherClass;

It seems like $dispatcherClass of type string is incompatible with the declared type object<FastRoute\Dispatcher> of property $dispatcherClass.

    }

    /**
     * Set the FastRoute dispatcher class name.
     *
     * @param string $className
     *
     * @return $this
     */
    public function dispatcherClass(string $className)
    {
        $this->dispatcherClass = $className;

It seems like $className of type string is incompatible with the declared type object<FastRoute\Dispatcher> of property $dispatcherClass.

        return $this;
    }

    /**
     * Process a server request and return a response.
     *
     * @param ServerRequestInterface $request
     * @param DelegateInterface $delegate
     *
     * @return ResponseInterface
     */
    public function process(ServerRequestInterface $request, DelegateInterface $delegate)
    {
        $dispatcherClass = $this->dispatcherClass;

        /** @var RouteCollector $router */
        $router     = $this->getContainer()->get(DefaultServiceProvider::SERVICE_ROUTE_COLLECTOR);
        $dispatcher = new $dispatcherClass($router->getData());
        $handler    = $this->dispatch($request, $dispatcher);
        $request    = $request->withAttribute($this->attribute, $handler);

        return $delegate->process($request);
    }

    /**
     * @param ServerRequestInterface $request
     * @param FastRouteDispatcher $dispatcher
     * @return \Closure The request handler callable
     * @throws HttpErrorException
     */
    public function dispatch(ServerRequestInterface $request, FastRouteDispatcher $dispatcher = null)
    {
        if (!$dispatcher) {
            /** @var RouteCollector $router */
            $router     = $this->getContainer()->get(DefaultServiceProvider::SERVICE_ROUTE_COLLECTOR);
            $dispatcher = new GroupCountBasedDispatcher($router->getData());
        }

        $match = $dispatcher->dispatch(
            strtoupper($request->getMethod()),
            $request->getUri()->getPath()
        );

        if ($match[0] === FastRouteDispatcher::NOT_FOUND) {
            throw HttpErrorException::create(404, ['request' => $request]);
        }

        if ($match[0] === FastRouteDispatcher::METHOD_NOT_ALLOWED) {
            throw HttpErrorException::create(405, ['request' => $request, 'allowed' => (array)$match[1]]);
        }

        /** @var CallableResolverInterface $resolver */
        $resolver = $this->getContainer()->get(DefaultServiceProvider::SERVICE_CALLABLE_RESOLVER);
        $callable = $resolver->resolve($match[1]);
        $params   = (array)$match[2];

        return function (...$args) use ($callable, $params) {
            $args[] = $params;
            return call_user_func($callable, ...$args);
        };
    }
}