Nip\Http\Kernel\Kernel

Complexity

Total Complexity

7

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	postRouting()	0	2	1
A	handleRaw()	0	5	1
A	handle()	0	17	3
A	__construct()	0	8	1
A	terminate()	0	4	1

<?php

namespace Nip\Http\Kernel;

use Exception;
use Nip\Application\ApplicationInterface;
use Nip\Dispatcher\ActionDispatcherMiddleware;

The type Nip\Dispatcher\ActionDispatcherMiddleware was not found. Maybe you did not declare it correctly or list all dependencies?

use Nip\Http\Kernel\Traits\HandleExceptionsTrait;

The type Nip\Http\Kernel\Traits\HandleExceptionsTrait was not found. Maybe you did not declare it correctly or list all dependencies?

use Nip\Http\Response\Response;
use Nip\Http\ServerMiddleware\Dispatcher;
use Nip\Http\ServerMiddleware\Traits\HasServerMiddleware;
use Nip\Request;
use Nip\Router\Middleware\RouteResolverMiddleware;
use Nip\Router\Router;
use Nip\Session\Middleware\StartSession;

The type Nip\Session\Middleware\StartSession was not found. Maybe you did not declare it correctly or list all dependencies?

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Symfony\Component\ErrorHandler\Error\FatalError;
use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\HttpKernel\HttpKernelInterface;
use Throwable;

/**
 * Class Kernel
 * @package Nip\Http\Kernel
 */
class Kernel implements KernelInterface
{
    use Traits\HandleExceptions;
    use Traits\HasApplication;

    use HasServerMiddleware;

    /**
     * The router instance.
     *
     * @var Router
     */
    protected $router;

    /**
     * The application's route middleware groups.
     *
     * @var array
     */
    protected $middlewareGroups = [];

    /**
     * The application's route middleware.
     *
     * @var array
     */
    protected $routeMiddleware = [];

    /**
     * Create a new HTTP kernel instance.
     *
     * @param ApplicationInterface $app
     * @param Router $router
     */
    public function __construct(ApplicationInterface $app, Router $router)
    {
        $this->app = $app;

It seems like $app of type Nip\Application\ApplicationInterface is incompatible with the declared type Nip\Application of property $app.

        $this->router = $router;

        $this->pushMiddleware(StartSession::class);
        $this->pushMiddleware(RouteResolverMiddleware::class);
        $this->pushMiddleware(ActionDispatcherMiddleware::class);
    }

    /**
     * Handle an incoming HTTP request.
     *
     * @param SymfonyRequest $request
     * @param int $type
     * @param bool $catch
     * @return ResponseInterface
     */
    public function handle(
        SymfonyRequest $request,
        int $type = HttpKernelInterface::MAIN_REQUEST,
        bool $catch = true
    ): \Symfony\Component\HttpFoundation\Response {
        try {
            $this->getApplication()->share('request', $request);
            return $this->handleRaw($request, $type);

$request of type Symfony\Component\HttpFoundation\Request is incompatible with the type Psr\Http\Message\ServerRequestInterface expected by parameter $request of Nip\Http\Kernel\Kernel::handleRaw().

The expression return $this->handleRaw($request, $type) returns the type Psr\Http\Message\ResponseInterface which is incompatible with the type-hinted return Symfony\Component\HttpFoundation\Response.

        } catch (Exception $e) {
            $this->reportException($e);
            $response = $this->renderException($request, $e);
        } catch (Throwable $e) {
            $this->reportException($e);
            $response = $this->renderException($request, $e);
        }
//        event(new Events\RequestHandled($request, $response));
        return $response;

The expression return $response could return the type Psr\Http\Message\ResponseInterface which is incompatible with the type-hinted return Symfony\Component\HttpFoundation\Response. Consider adding an additional type-check to rule them out.

    }

    /**
     * Handles a request to convert it to a response.
     *
     * @param ServerRequestInterface $request A Request instance
     * @param int $type The type of the request
     *
     * @return ResponseInterface A Response instance
     *
     * @throws \LogicException       If one of the listener does not behave as expected
     * @throws NotFoundHttpException When controller cannot be found
     */
    protected function handleRaw(ServerRequestInterface $request, $type = self::MASTER_REQUEST)

The constant Symfony\Component\HttpKernel\HttpKernelInterface::MASTER_REQUEST has been deprecated: since symfony/http-kernel 5.3, use MAIN_REQUEST instead. To ease the migration, this constant won't be removed until Symfony 7.0.

The parameter $type is not used and could be removed.

    {
        return (
        new Dispatcher($this->middleware, $this->getApplication()->getContainer())
        )->dispatch($request);
    }

    /**
     * @param Request $request
     * @param Response $response
     */
    public function terminate(RequestInterface $request, ResponseInterface $response)
    {
        $this->terminateMiddleware($request, $response);
        $this->getApplication()->terminate();
    }

    public function postRouting()
    {
    }
}