Rade\Application

Complexity

Total Complexity

43

Size/Duplication

Total Lines	296
Duplicated Lines	0 %

Test Coverage

Coverage

34.95%

Importance

Changes	7
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	21	3
A	match()	0	3	1
A	pipe()	0	3	1
A	getDispatcher()	0	3	1
A	delete()	0	3	1
A	handleRouterException()	0	17	4
A	generateUri()	0	3	1
A	handleThrowable()	0	29	6
A	post()	0	3	1
A	resolveMiddlewares()	0	15	6
A	put()	0	3	1
A	pipes()	0	3	1
A	handle()	0	25	6
A	group()	0	3	1
A	createWelcomeResponse()	0	11	1
A	strictAutowiring()	0	3	1
A	run()	0	23	5
A	options()	0	3	1
A	patch()	0	3	1

<?php

declare(strict_types=1);

/*
 * This file is part of DivineNii opensource projects.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2019 DivineNii (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Rade;

use Biurad\Http\{Interfaces\Psr17Interface, Request, Response, Response\HtmlResponse};
use Biurad\Http\Factory\Psr17Factory;
use Flight\Routing\{Exceptions\RouteNotFoundException, Route, RouteCollection, Router};
use Fig\Http\Message\RequestMethodInterface;
use Flight\Routing\Generator\GeneratedUri;
use Flight\Routing\Interfaces\RouteMatcherInterface;
use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
use Psr\Http\Server\{MiddlewareInterface, RequestHandlerInterface};
use Laminas\Stratigility\Middleware\{CallableMiddlewareDecorator, RequestHandlerMiddleware};
use Laminas\{HttpHandlerRunner\Emitter\SapiStreamEmitter, Stratigility\Utils};

The type Laminas\HttpHandlerRunner\Emitter\SapiStreamEmitter was not found. Maybe you did not declare it correctly or list all dependencies?

use Psr\EventDispatcher\EventDispatcherInterface;
use Rade\DI\Definitions\{Reference, Statement};
use Symfony\Component\Console\Application as ConsoleApplication;
use Symfony\Component\HttpFoundation\RequestStack;

/**
 * The Rade framework core class.
 *
 * @author Divine Niiquaye Ibok <divineibok@gmail.com>
 */
class Application extends DI\Container implements RouterInterface, KernelInterface
{
    use Traits\HelperTrait;

    public const VERSION = '2.0.0-DEV';

    /**
     * Instantiate a new Application.
     */
    public function __construct(Psr17Interface $psr17Factory = null, EventDispatcherInterface $dispatcher = null, bool $debug = false)
    {
        parent::__construct();

        if (!isset($this->parameters['project.compiled_container_class'])) {
            $this->definitions = [
                'http.router' => Router::withCollection(),
                'request_stack' => new RequestStack(),
                'psr17.factory' => $psr17Factory = $psr17Factory ?? new Psr17Factory(),
                'events.dispatcher' => $dispatcher = $dispatcher ?? new Handler\EventHandler(),
            ];
            $this->types += [
                RequestStack::class => ['request_stack'],
                Router::class => ['http.router'],
                RouteMatcherInterface::class => ['http.router'],
            ];
            $this->types(['psr17.factory' => DI\Resolver::autowireService($psr17Factory), 'events.dispatcher' => DI\Resolver::autowireService($dispatcher)]);
        }

        if (!isset($this->parameters['debug'])) {
            $this->parameters['debug'] = $debug;
        }
    }

    /**
     * If true, exception will be thrown on resolvable services with are not typed.
     */
    public function strictAutowiring(bool $boolean = true): void
    {
        $this->resolver->setStrictAutowiring($boolean);
    }

    public function getDispatcher(): EventDispatcherInterface
    {
        return $this->services['events.dispatcher'] ?? $this->get('events.dispatcher');

The expression return $this->services['events.dispatcher'] ?? $this->get('events.dispatcher') could return the type array|mixed which is incompatible with the type-hinted return Psr\EventDispatcher\EventDispatcherInterface. Consider adding an additional type-check to rule them out.

    }

    /**
     * {@inheritdoc}
     *
     * @param MiddlewareInterface|RequestHandlerInterface|Reference|Statement|callable ...$middlewares
     */
    public function pipe(object ...$middlewares): void
    {
        $this->get('http.router')->pipe(...$this->resolveMiddlewares($middlewares));
    }

    /**
     * {@inheritdoc}
     *
     * @param MiddlewareInterface|RequestHandlerInterface|Reference|Statement|callable ...$middlewares
     */
    public function pipes(string $named, object ...$middlewares): void
    {
        $this->get('http.router')->pipes($named, ...$this->resolveMiddlewares($middlewares));
    }

    /**
     * {@inheritdoc}
     */
    public function generateUri(string $routeName, array $parameters = []): GeneratedUri
    {
        return $this->get('http.router')->generateUri($routeName, $parameters);
    }

    /**
     * {@inheritdoc}
     */
    public function match(string $pattern, array $methods = Route::DEFAULT_METHODS, $to = null): Route
    {
        return ($this->services['http.router'] ?? $this->get('http.router'))->getCollection()->addRoute($pattern, $methods, $to)->getRoute();
    }

    /**
     * {@inheritdoc}
     */
    public function post(string $pattern, $to = null): Route
    {
        return $this->match($pattern, [RequestMethodInterface::METHOD_POST], $to);
    }

    /**
     * {@inheritdoc}
     */
    public function put(string $pattern, $to = null): Route
    {
        return $this->match($pattern, [RequestMethodInterface::METHOD_PUT], $to);
    }

    /**
     * {@inheritdoc}
     */
    public function delete(string $pattern, $to = null): Route
    {
        return $this->match($pattern, [RequestMethodInterface::METHOD_DELETE], $to);
    }

    /**
     * {@inheritdoc}
     */
    public function options(string $pattern, $to = null): Route
    {
        return $this->match($pattern, [RequestMethodInterface::METHOD_OPTIONS], $to);
    }

    /**
     * {@inheritdoc}
     */
    public function patch(string $pattern, $to = null): Route
    {
        return $this->match($pattern, [RequestMethodInterface::METHOD_PATCH], $to);
    }

    /**
     * {@inheritdoc}
     */
    public function group(string $prefix, $collection = null): RouteCollection
    {
        return $this->get('http.router')->getCollection()->group($prefix, $collection);
    }

    /**
     * Handles the request and delivers the response.
     *
     * @param ServerRequestInterface|null $request Request to process
     *
     * @throws \Throwable
     *
     * @return int|bool
     */
    public function run(ServerRequestInterface $request = null, bool $catch = true)
    {
        if ($this->isRunningInConsole()) {
            $this->get(ConsoleApplication::class)->run();
        }

        if (null === $request) {
            $request = $this->get('psr17.factory')->fromGlobalRequest();
        }

        $response = $this->handle($request, $catch);

        if ($response instanceof Response) {
            $response->getResponse()->send();

            return true;
        }

        if (class_exists(SapiStreamEmitter::class)) {
            return (new SapiStreamEmitter())->emit($response);
        }

        throw new \RuntimeException(\sprintf('Unable to emit response onto the browser. Try running "composer require laminas/laminas-httphandlerrunner".'));
    }

    /**
     * Handles a request to convert it to a response.
     *
     * Exceptions are not caught.
     *
     * @param bool $catch Whether to catch exceptions or not
     */
    public function handle(ServerRequestInterface $request, bool $catch = true): ResponseInterface
    {
        if (!$this->has(RequestHandlerInterface::class)) {
            $this->definitions[RequestHandlerInterface::class] = new Handler\RouteHandler($this);
        }

        try {
            $response = $this->get('http.router')->process($request, $this->get(RequestHandlerInterface::class));

            if ($request instanceof Request) {
                $request = $request->withRequest($this->get('request_stack')->getMainRequest());
            }

            $this->getDispatcher()->dispatch($event = new Event\ResponseEvent($this, $request, $response));

It seems like $request can also be of type Biurad\Http\Request; however, parameter $request of Rade\Event\ResponseEvent::__construct() does only seem to accept Psr\Http\Message\ServerRequestInterface, maybe add an additional type check?

        } catch (\Throwable $e) {
            if (!$catch || $this->isRunningInConsole()) {
                throw $e;
            }

            return $this->handleThrowable($e, $request);

It seems like $request can also be of type Biurad\Http\Request; however, parameter $request of Rade\Application::handleThrowable() does only seem to accept Psr\Http\Message\ServerRequestInterface, maybe add an additional type check?

        } finally {
            $this->getDispatcher()->dispatch(new Event\TerminateEvent($this, $request));

It seems like $request can also be of type Biurad\Http\Request; however, parameter $request of Rade\Event\TerminateEvent::__construct() does only seem to accept Psr\Http\Message\ServerRequestInterface, maybe add an additional type check?

        }

        return $event->getResponse();
    }

    /**
     * Handle RouteNotFoundException for Flight Routing.
     *
     * @return RouteNotFoundException|ResponseInterface
     */
    protected function handleRouterException(RouteNotFoundException $e, ServerRequestInterface $request)
    {
        if (empty($pathInfo = $request->getServerParams()['PATH_INFO'] ?? '')) {
            $pathInfo = $request->getUri()->getPath();
        }

        if ('/' === $pathInfo) {
            return $this->createWelcomeResponse();
        }

        $message = $e->getMessage();

        if ('' !== $referer = $request->getHeaderLine('referer')) {
            $message .= \sprintf(' (from "%s")', $referer);
        }

        return new RouteNotFoundException($message, 404);
    }

    /**
     * Handles a throwable by trying to convert it to a Response.
     *
     * @throws \Throwable
     */
    protected function handleThrowable(\Throwable $e, ServerRequestInterface $request): ResponseInterface
    {
        if ($request instanceof Request) {
            $this->get('request_stack')->push($request->getRequest());
        }

        $this->getDispatcher()->dispatch($event = new Event\ExceptionEvent($this, $request, $e));

        // a listener might have replaced the exception
        $e = $event->getThrowable();

        if (null === $response = $event->getResponse()) {
            if ($e instanceof RouteNotFoundException) {
                $e = $this->handleRouterException($e, $request);

                if ($e instanceof ResponseInterface) {
                    return $e;
                }
            }

            throw $e;
        }

        // ensure that we actually have an error response and keep the HTTP status code and headers
        if (!$event->isAllowingCustomResponseCode()) {
            $response = $response->withStatus(Utils::getStatusCode($e, $response));
        }

        return $response;
    }

    /**
     * The default welcome page for application.
     */
    protected function createWelcomeResponse(): ResponseInterface
    {
        $debug = $this->parameters['debug'];
        $version = self::VERSION;
        $docVersion = $version[0] . '.x.x';

        \ob_start();

        include __DIR__ . '/Resources/welcome.phtml';

        return new HtmlResponse((string) \ob_get_clean(), 404);
    }

    /**
     * Resolve Middlewares.
     *
     * @param array<int,MiddlewareInterface|RequestHandlerInterface|Reference|Statement|callable> $middlewares
     *
     * @return array<int,MiddlewareInterface>
     */
    protected function resolveMiddlewares(array $middlewares): array
    {
        foreach ($middlewares as $offset => $middleware) {
            if ($middleware instanceof RequestHandlerInterface) {
                $middlewares[$offset] = new RequestHandlerMiddleware($middleware);
            } elseif ($middleware instanceof Statement) {
                $middlewares[$offset] = $this->resolver->resolve($middleware->getValue(), $middleware->getArguments());
            } elseif ($middleware instanceof Reference) {
                $middlewares[$offset] = $this->get((string) $middleware);
            } elseif (\is_callable($middleware)) {
                $middlewares[$offset] = new CallableMiddlewareDecorator($middleware);

It seems like $middleware can also be of type Psr\Http\Server\MiddlewareInterface; however, parameter $middleware of Laminas\Stratigility\Middleware\CallableMiddlewareDecorator::__construct() does only seem to accept callable, maybe add an additional type check?

            }
        }

        return $middlewares;
    }
}