BrainExe\Core\Application\AppKernel

Complexity

Total Complexity

14

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

95.45%

Importance

Changes	10
Bugs	0	Features	3

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	handle()	0	16	2
A	handleRequest()	0	23	3
A	prepareResponse()	0	12	3
A	applyResponseMiddleware()	0	8	2
A	applyExceptionMiddleware()	0	11	3

<?php

namespace BrainExe\Core\Application;

use BrainExe\Annotations\Annotations\Inject;
use BrainExe\Annotations\Annotations\Service;
use BrainExe\Core\Middleware\MiddlewareInterface;
use Throwable;
use Exception;
use Generator;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\HttpKernelInterface;

/**
 * @Service(public=true)
 */
class AppKernel implements HttpKernelInterface
{

    /**
     * @var ControllerResolver
     */
    private $resolver;

    /**
     * @var SerializedRouteCollection
     */
    private $routes;

    /**
     * @var UrlMatcher
     */
    private $urlMatcher;

    /**
     * @var MiddlewareInterface[]
     */
    private $middlewares;

    /**
     * @Inject({
     *     "@ControllerResolver",
     *     "@Core.RouteCollection",
     *     "@UrlMatcher",
     *     null
     * })
     * @param ControllerResolver $resolver
     * @param SerializedRouteCollection $routes
     * @param UrlMatcher $urlMatcher
     * @param MiddlewareInterface[] $middlewares
     */
    public function __construct(
        ControllerResolver $resolver,
        SerializedRouteCollection $routes,
        UrlMatcher $urlMatcher,
        array $middlewares
    ) {
        $this->resolver    = $resolver;
        $this->routes      = $routes;
        $this->urlMatcher  = $urlMatcher;
        $this->middlewares = $middlewares;
    }

    /**
     * {@inheritdoc}
     */
    public function handle(Request $request, $type = self::MASTER_REQUEST, $catch = true)
    {
        $response = null;

        try {
            $response = $this->handleRequest($request);
        } catch (Throwable $exception) {
            $response = $this->applyExceptionMiddleware($request, $exception);

$exception of type object<Throwable> is not a sub-type of object<Exception>. It seems like you assume a concrete implementation of the interface Throwable to be always present.

        }

        $response = $this->prepareResponse($response);

        $this->applyResponseMiddleware($request, $response);

        return $response;
    }

    /**
     * @param Request $request
     * @return Response|mixed
     */
    private function handleRequest(Request $request)
    {
        // match route and set attributes in request object
        $attributes = $this->urlMatcher->match($request);
        $request->attributes->replace($attributes);

        $routeName = $attributes['_route'];
        $route     = $this->routes->get($routeName);

        foreach ($this->middlewares as $middleware) {
            $response = $middleware->processRequest($request, $route);
            if ($response) {
                // e.g. RedirectResponse or rendered error page
                return $response;
            }
        }

        /** @var callable $callable */
        $callable  = $this->resolver->getController($request);
        $arguments = $this->resolver->getArguments($request, $callable);

        return $callable(...$arguments);
    }

    /**
     * @param Response|mixed $response
     * @return Response
     */
    private function prepareResponse($response) : Response
    {
        if ($response instanceof Generator) {
            $response = iterator_to_array($response);
        }

        if (!$response instanceof Response) {
            return new JsonResponse($response);
        }

        return $response;
    }

    /**
     * @param Request $request
     * @param Response $response
     */
    protected function applyResponseMiddleware(Request $request, Response $response)
    {
        $middlewareIdx = count($this->middlewares) - 1;
        for ($i = $middlewareIdx; $i >= 0; $i--) {
            $middleware = $this->middlewares[$i];
            $middleware->processResponse($request, $response);
        }
    }

    /**
     * @param Request $request
     * @param Exception $exception
     * @return Response|null
     */
    protected function applyExceptionMiddleware(Request $request, Exception $exception)
    {
        foreach ($this->middlewares as $middleware) {
            $response = $middleware->processException($request, $exception);
            if ($response !== null) {
                return $response;
            }
        }

        return null;
    }
}