Rade\Application

Complexity

Total Complexity

42

Size/Duplication

Total Lines	295
Duplicated Lines	0 %

Test Coverage

Coverage

36.45%

Importance

Changes	5
Bugs	0	Features	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	24	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	25	5
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};

Compound namespaces cannot have a depth more than 2

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 (empty($this->methodsMap)) {
            $this->definitions['http.router'] = Router::withCollection();
            $this->definitions['request_stack'] = new RequestStack();
            $this->definitions['psr17.factory'] = $psr17Factory = ($psr17Factory ?? new Psr17Factory());
            $this->definitions['events.dispatcher'] = $dispatcher = ($dispatcher ?? new Handler\EventHandler());

            $this->types(
                [
                    'http.router' => [Router::class, RouteMatcherInterface::class],
                    'request_stack' => [RequestStack::class],
                    'psr17.factory' => DI\Resolver::autowireService($psr17Factory),
                    'events.dispatcher' => DI\Resolver::autowireService($dispatcher),
                ]
            );

            unset($psr17Factory, $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');
    }

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

The method pipe() does not exist on PhpParser\Builder\Method.

The method pipe() does not exist on Rade\DI\Container. Are you sure you never get this type here, but always one of the subclasses?

    }

    /**
     * {@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));

The method pipes() does not exist on PhpParser\Builder\Method.

The method pipes() does not exist on Rade\DI\Container. Are you sure you never get this type here, but always one of the subclasses?

    }

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

The method generateUri() does not exist on Rade\DI\Container. Are you sure you never get this type here, but always one of the subclasses?

The method generateUri() does not exist on PhpParser\Builder\Method.

The expression return $this->get('http.router')->generateUri($routeName, $parameters) returns the type Flight\Routing\Generator\GeneratedUri which is incompatible with the return type mandated by Rade\RouterInterface::generateUri() of Rade\GeneratedUri.

    }

    /**
     * {@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();

The method getCollection() does not exist on PhpParser\Builder\Method.

The method getCollection() does not exist on Rade\Application.

The method getCollection() does not exist on Rade\DI\Container.

    }

    /**
     * {@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();

The method run() does not exist on PhpParser\Builder\Method.

The method run() does not exist on Rade\DI\Container. Are you sure you never get this type here, but always one of the subclasses?

        }

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

The method fromGlobalRequest() does not exist on Rade\Application.

The method fromGlobalRequest() does not exist on Rade\DI\Container.

The method fromGlobalRequest() does not exist on PhpParser\Builder\Method.

        }

        $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));

The method process() does not exist on PhpParser\Builder\Method.

The method process() does not exist on Rade\DI\Container.

The method process() does not exist on Rade\Application.

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

The method getMainRequest() does not exist on Rade\Application.

The method getMainRequest() does not exist on PhpParser\Builder\Method.

The method getMainRequest() does not exist on Rade\DI\Container.

            }

            $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
    {
        $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;
    }
}