Dispatcher::formatValidationResponse() - Code Metrics - Inspection of "feat: helper route()" - blitz-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( c1749a...759bea )

by Dimitri
created 2023-11-07 17:35 UTC
Dispatcher::formatValidationResponse() B

↳ Parent: Dispatcher
Complexity

Conditions	7
Paths	12
Size

Total Lines	25
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	56
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	7
eloc	15
c	1
b	0
f	0
nc	12
nop	3
dl	0
loc	25
ccs	0
cts	6
cp	0
crap	56
rs	8.8333
<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <[email protected]>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Router;

use BlitzPHP\Cache\ResponseCache;
use BlitzPHP\Container\Container;
use BlitzPHP\Container\Services;
use BlitzPHP\Contracts\Event\EventManagerInterface;
use BlitzPHP\Contracts\Http\ResponsableInterface;
use BlitzPHP\Contracts\Router\RouteCollectionInterface;
use BlitzPHP\Contracts\Support\Responsable;
use BlitzPHP\Controllers\BaseController;
use BlitzPHP\Controllers\RestController;
use BlitzPHP\Core\App;
use BlitzPHP\Debug\Timer;
use BlitzPHP\Exceptions\FrameworkException;
use BlitzPHP\Exceptions\PageNotFoundException;
use BlitzPHP\Exceptions\RedirectException;
use BlitzPHP\Exceptions\ValidationException;
use BlitzPHP\Http\Middleware;
use BlitzPHP\Http\Response;
use BlitzPHP\Http\ServerRequest;
use BlitzPHP\Http\Uri;
use BlitzPHP\Utilities\Helpers;
use BlitzPHP\View\View;
use Closure;
use Exception;
use InvalidArgumentException;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use stdClass;
use Throwable;

/**
 * Cette classe est la porte d'entree du framework. Elle analyse la requete,
 * recherche la route correspondante et invoque le bon controleurm puis renvoie la reponse.
 */
class Dispatcher
{
    /**
     * Heure de démarrage de l'application.
     *
     * @var mixed
     */
    protected $startTime;

    /**
     * Durée totale d'exécution de l'application
     *
     * @var float
     */
    protected $totalTime;

    /**
     * Main application configuration
     *
     * @var stdClass
     */
    protected $config;

    /**
     * instance Timer.
     *
     * @var Timer
     */
    protected $timer;

    /**
     * requête courrante.
     *
     * @var ServerRequest
     */
    protected $request;

    /**
     * Reponse courrante.
     *
     * @var Response
     */
    protected $response;

    /**
     * Router à utiliser.
     *
     * @var Router
     */
    protected $router;

    /**
     * @var Middleware
     */
    private $middleware;

    /**
     * Contrôleur à utiliser.
     *
     * @var Closure|string
     */
    protected $controller;

    /**
     * Méthode du ontrôleur à exécuter.
     *
     * @var string
     */
    protected $method;

    /**
     * Gestionnaire de sortie à utiliser.
     *
     * @var string
     */
    protected $output;

    /**
     * Chemin de requête à utiliser.
     *
     * @var string
     *
     * @deprecated No longer used.
     */
    protected $path;

    /**
     * Niveau de mise en mémoire tampon de sortie de l'application
     */
    protected int $bufferLevel = 0;

    /**
     * Mise en cache des pages Web
     */
    protected ResponseCache $pageCache;

    /**
     * Constructeur.
     */
    public function __construct(protected EventManagerInterface $event, protected Container $container)
    {
        $this->startTime = microtime(true);
        $this->config    = (object) config('app');


        $this->pageCache = Services::responsecache();
    }

    /**
     * Retourne la methode invoquee
     */
    public static function getMethod(): ?string
    {
        $method = Services::singleton(self::class)->method;
        if (empty($method)) {
            $method = Services::routes()->getDefaultMethod();
        }

        return $method;
    }

    /**
     * Retourne le contrôleur utilisé
     *
     * @return Closure|string
     */
    public static function getController(bool $fullName = true)
    {
        $routes = Services::routes();

        $controller = Services::singleton(self::class)->controller;
        if (empty($controller)) {
            $controller = $routes->getDefaultController();
        }

        if (! $fullName && is_string($controller)) {
            $controller = str_replace($routes->getDefaultNamespace(), '', $controller);
        }

        return $controller;
    }

    /**
     * Lancez l'application !
     *
     * C'est "la boucle" si vous voulez. Le principal point d'entrée dans le script
     * qui obtient les instances de classe requises, déclenche les filtres,
     * essaie d'acheminer la réponse, charge le contrôleur et généralement
     * fait fonctionner toutes les pièces ensemble.
     *
     * @return bool|mixed|ResponseInterface|ServerRequestInterface
     *
     * @throws Exception
     * @throws RedirectException
     */
    public function run(?RouteCollectionInterface $routes = null, bool $returnResponse = false)
    {
        $this->pageCache->setTtl(0);
        $this->bufferLevel = ob_get_level();

        $this->startBenchmark();

        $this->getRequestObject();
        $this->getResponseObject();

        $this->initMiddlewareQueue();

        try {
            $this->response = $this->handleRequest($routes, config('cache'));
            $this->response = $this->handleRequest($routes, /** @scrutinizer ignore-type */ config('cache'));
        } catch (RedirectException|ResponsableInterface $e) {
            $this->outputBufferingEnd();
            if ($e instanceof RedirectException) {
                $e = new RedirectException($e->getMessage(), $e->getCode(), $e);
            }

            $this->response = $e->getResponse();
        } catch (PageNotFoundException $e) {
            $this->response = $this->display404errors($e);
        } catch (Throwable $e) {
            $this->outputBufferingEnd();

            throw $e;
        }

        if ($returnResponse) {
            return $this->response;
        }

        $this->sendResponse();
    }

    /**
     * Gère la logique de requête principale et déclenche le contrôleur.
     *
     * @throws PageNotFoundException
     * @throws RedirectException
     */
    protected function handleRequest(?RouteCollectionInterface $routes = null, ?array $cacheConfig = null): ResponseInterface
    {
        $this->forceSecureAccess();

        $this->event->trigger('pre_system');

        // Recherchez une page en cache.
        // L'exécution s'arrêtera si la page a été mise en cache.
        if (($response = $this->displayCache($cacheConfig)) instanceof ResponseInterface) {

            return $response;
        }

        $routeMiddlewares = (array) $this->dispatchRoutes($routes);

        // Le bootstrap dans un middleware
        $this->middleware->alias('blitz', $this->bootApp());

        /**
         * Ajouter des middlewares de routes
         */
        foreach ($routeMiddlewares as $middleware) {
            $this->middleware->append($middleware);
        }

        $this->middleware->append('blitz');

        // Enregistrer notre URI actuel en tant qu'URI précédent dans la session
        // pour une utilisation plus sûre et plus précise avec la fonction d'assistance `previous_url()`.
        $this->storePreviousURL(current_url(true));

        /**
         * Emission de la reponse
         */
        $this->gatherOutput($this->middleware->handle($this->request));

        // Y a-t-il un événement post-système ?
        $this->event->trigger('post_system');

        return $this->response;
    }

    /**
     * Démarrer le benchmark
     *
     * La minuterie est utilisée pour afficher l'exécution totale du script à la fois dans la
     * barre d'outils de débogage, et éventuellement sur la page affichée.
     */
    protected function startBenchmark()
    {
        if ($this->startTime === null) {
            $this->startTime = microtime(true);
        }

        $this->timer = Services::timer();
        $this->timer->start('total_execution', $this->startTime);
        $this->timer->start('total_execution', /** @scrutinizer ignore-type */ $this->startTime);
        $this->timer->start('bootstrap');
    }

    /**
     * Définit un objet Request à utiliser pour cette requête.
     * Utilisé lors de l'exécution de certains tests.
     */
    public function setRequest(ServerRequestInterface $request): self
    {
        $this->request = $request;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}

        return $this;
    }

    /**
     * Obtenez notre objet Request et définissez le protocole du serveur en fonction des informations fournies
     * par le serveur.
     */
    protected function getRequestObject()
    {
        if ($this->request instanceof ServerRequestInterface) {

            return;
        }

        if (is_cli() && ! on_test()) {
            // @codeCoverageIgnoreStart
            // $this->request = Services::clirequest($this->config);
            // @codeCoverageIgnoreEnd
        }

        $version = $_SERVER['SERVER_PROTOCOL'] ?? 'HTTP/1.1';
        if (! is_numeric($version)) {
            $version = substr($version, strpos($version, '/') + 1);
        }

        // Assurez-vous que la version est au bon format
        $version = number_format((float) $version, 1);

        $this->request = Services::request()->withProtocolVersion($version);
    }

    /**
     * Obtenez notre objet Response et définissez des valeurs par défaut, notamment
     * la version du protocole HTTP et une réponse réussie par défaut.
     */
    protected function getResponseObject()
    {
        // Supposons le succès jusqu'à preuve du contraire.
        $this->response = Services::response()->withStatus(200);

        if (! is_cli() || on_test()) {
        }

        $this->response = $this->response->withProtocolVersion($this->request->getProtocolVersion());
    }

    /**
     * Forcer l'accès au site sécurisé ? Si la valeur de configuration 'forceGlobalSecureRequests'
     * est vrai, imposera que toutes les demandes adressées à ce site soient effectuées via
     * HTTPS. Redirigera également l'utilisateur vers la page actuelle avec HTTPS
     * comme défini l'en-tête HTTP Strict Transport Security pour ces navigateurs
     * qui le supportent.
     *
     * @param int $duration Combien de temps la sécurité stricte des transports
     *                      doit être appliqué pour cette URL.
     */
    protected function forceSecureAccess($duration = 31536000)
    {
        if ($this->config->force_global_secure_requests !== true) {
            return;
        }

        force_https($duration, $this->request, $this->response);
    }

    /**
     * Détermine si une réponse a été mise en cache pour l'URI donné.
     *
     * @return bool|ResponseInterface
     *
     * @throws FrameworkException
     */
    public function displayCache(?array $config = null)
    {
        if ($cachedResponse = $this->pageCache->get($this->request, $this->response)) {
            $this->response = $cachedResponse;

            $this->totalTime = $this->timer->getElapsedTime('total_execution');
            $output          = $this->displayPerformanceMetrics($cachedResponse->getBody());

            return $this->response->withBody(to_stream($output));
        }

        return false;
    }

    /**
     * Renvoie un tableau avec nos statistiques de performances de base collectées.
     */
    public function getPerformanceStats(): array
    {
        return [
            'startTime' => $this->startTime,
            'totalTime' => $this->totalTime,
        ];
    }

    /**
     * Remplace les balises memory_usage et elapsed_time.
     */
    public function displayPerformanceMetrics(string $output): string
    {
        $this->totalTime = $this->timer->getElapsedTime('total_execution');

        return str_replace('{elapsed_time}', (string) $this->totalTime, $output);
    }

    /**
     * Fonctionne avec le routeur pour
     * faire correspondre une route à l'URI actuel. Si la route est une
     * "route de redirection", gérera également la redirection.
     *
     * @param RouteCollectionInterface|null $routes Une interface de collecte à utiliser à la place
     *                                              du fichier de configuration.
     *
     * @return string[]
     *
     * @throws RedirectException
     */
    protected function dispatchRoutes(?RouteCollectionInterface $routes = null): array
    {
        if ($routes === null) {
            $routes = Services::routes()->loadRoutes();
        }

        $this->router = Services::router($routes, $this->request, false);

        $path = $this->determinePath();

        $this->timer->stop('bootstrap');
        $this->timer->start('routing');

        $this->outputBufferingStart();

        $this->controller = $this->router->handle($path ?: '/');
        $this->method     = $this->router->methodName();

        // Si un segment {locale} correspondait dans la route finale,
        // alors nous devons définir les paramètres régionaux corrects sur notre requête.
        if ($this->router->hasLocale()) {
            $this->request = $this->request->withLocale($this->router->getLocale());
        }

        $this->timer->stop('routing');

        return $this->router->getMiddlewares();
    }

    /**
     * Détermine le chemin à utiliser pour que nous essayions d'acheminer vers, en fonction
     * de l'entrée de l'utilisateur (setPath), ou le chemin CLI/IncomingRequest.
     */
    protected function determinePath(): string
    {
        if (! empty($this->path)) {
        if (! empty(/** @scrutinizer ignore-deprecated */ $this->path)) {
            return $this->path;
            return /** @scrutinizer ignore-deprecated */ $this->path;
        }

        $path = method_exists($this->request, 'getPath')
            ? $this->request->getPath()
            : $this->request->getUri()->getPath();

        return $this->path = preg_replace('#^' . App::getUri()->getPath() . '#i', '', $path);
        return /** @scrutinizer ignore-deprecated */ $this->path = preg_replace('#^' . App::getUri()->getPath() . '#i', '', $path);
    }

    /**
     * Maintenant que tout a été configuré, cette méthode tente d'exécuter le
     * méthode du contrôleur et lancez le script. S'il n'en est pas capable, le fera
     * afficher l'erreur Page introuvable appropriée.
     */
    protected function startController(ServerRequest $request, Response $response)
    {
        // Aucun contrôleur spécifié - nous ne savons pas quoi faire maintenant.
        if (empty($this->controller)) {
            throw PageNotFoundException::emptyController();
        }

        $this->timer->start('controller');
        $this->timer->start('controller_constructor');

        // Est-il acheminé vers une Closure ?
        if (is_object($this->controller) && (get_class($this->controller) === 'Closure')) {
            $controller = $this->controller;

            $sendParameters = [];

            foreach ($this->router->params() as $parameter) {
                $sendParameters[] = $parameter;
            }
            array_push($sendParameters, $request, $response);

            return $this->container->call($controller, $sendParameters);
        }

        // Essayez de charger automatiquement la classe
        if (! class_exists($this->controller, true) || ($this->method[0] === '_' && $this->method !== '__invoke')) {
        if (! class_exists(/** @scrutinizer ignore-type */ $this->controller, true) || ($this->method[0] === '_' && $this->method !== '__invoke')) {
            throw PageNotFoundException::controllerNotFound($this->controller, $this->method);
            throw PageNotFoundException::controllerNotFound(/** @scrutinizer ignore-type */ $this->controller, $this->method);
        }

        return null;
    }

    /**
     * Instancie la classe contrôleur.
     *
     * @return \BlitzPHP\Controllers\BaseController|mixed
     */
    private function createController(ServerRequestInterface $request, ResponseInterface $response)
    {
        /**
         * @var \BlitzPHP\Controllers\BaseController
         */
        $class = $this->container->get($this->controller);
        $class = $this->container->get(/** @scrutinizer ignore-type */ $this->controller);

        if (method_exists($class, 'initialize')) {
            $class->initialize($request, $response, Services::logger());
        }

        $this->timer->stop('controller_constructor');

        return $class;
    }

    /**
     * Exécute le contrôleur, permettant aux méthodes _remap de fonctionner.
     *
     * @param mixed $class
     *
     * @return mixed
     */
    protected function runController($class)
    {
        // S'il s'agit d'une demande de console, utilisez les segments d'entrée comme paramètres
        $params = defined('KLINGED') ? [/* $this->request->getSegments() */] : $this->router->params();
        $method = $this->method;

        if (method_exists($class, '_remap')) {
            $params = [$method, $params];
            $method = '_remap';
        }

        $output = $this->container->call([$class, $method], (array) $params);

        $this->timer->stop('controller');

        if ($output instanceof View) {
            $output = $this->response->withBody(to_stream($output->get()));
        }

        return $output;
    }

    /**
     * Affiche une page d'erreur 404 introuvable. S'il est défini, essaiera de
     * appelez le contrôleur/méthode 404Override qui a été défini dans la configuration de routage.
     */
    protected function display404errors(PageNotFoundException $e)
    {
        // Existe-t-il une dérogation 404 disponible ?
        if ($override = $this->router->get404Override()) {
            $returned = null;

            if ($override instanceof Closure) {

                echo $override($e->getMessage());
            } elseif (is_array($override)) {

                $this->timer->start('controller');
                $this->timer->start('controller_constructor');

                $this->controller = $override[0];
                $this->method     = $override[1];

                $controller = $this->createController($this->request, $this->response);
                $returned   = $this->runController($controller);
            }

            unset($override);

            $this->gatherOutput($returned);

            return $this->response;
        }

        // Affiche l'erreur 404
        $this->response = $this->response->withStatus($e->getCode());

        $this->outputBufferingEnd();

        throw PageNotFoundException::pageNotFound(! on_prod() || is_cli() ? $e->getMessage() : '');
    }

    /**
     * Rassemble la sortie du script à partir du tampon, remplace certaines balises d'exécutions
     * d'horodatage dans la sortie et affiche la barre d'outils de débogage, si nécessaire.
     *
     * @param mixed|null $returned
     */
    protected function gatherOutput($returned = null)
    {
        $this->output = $this->outputBufferingEnd();

        // Si le contrôleur a renvoyé un objet de réponse,
        // nous devons en saisir le corps pour qu'il puisse
        // être ajouté à tout ce qui aurait déjà pu être ajouté avant de faire le écho.
        // Nous devons également enregistrer l'instance localement
        // afin que tout changement de code d'état, etc., ait lieu.
        if ($returned instanceof ResponseInterface) {
            $this->response = $returned;
class Alien {}

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
            $returned       = $returned->getBody()->getContents();
        }

        if (is_string($returned)) {
            $this->output .= $returned;
        }

        $this->response = $this->response->withBody(to_stream($this->output));
    }

    /**
     * Si nous avons un objet de session à utiliser, stockez l'URI actuel
     * comme l'URI précédent. Ceci est appelé juste avant d'envoyer la
     * réponse au client, et le rendra disponible à la prochaine demande.
     *
     * Cela permet au fournisseur une détection plus sûre et plus fiable de la fonction previous_url().
     *
     * @param \BlitzPHP\Http\Uri|string $uri
     */
    public function storePreviousURL($uri)
    {
        // Ignorer les requêtes CLI
        if (is_cli() && ! on_test()) {
            return; // @codeCoverageIgnore
        }

        // Ignorer les requêtes AJAX
        if (method_exists($this->request, 'isAJAX') && $this->request->isAJAX()) {
        if (method_exists($this->request, 'isAJAX') && $this->request->/** @scrutinizer ignore-call */ isAJAX()) {
            return;
        }

        // Ignorer les reponses non-HTML
        if (! str_contains($this->response->getHeaderLine('Content-Type'), 'text/html')) {
            return;
        }

        // Ceci est principalement nécessaire lors des tests ...
        if (is_string($uri)) {
            $uri = Services::uri($uri, false);
        }

        Services::session()->setPreviousUrl(Uri::createURIString(
            $uri->getScheme(),
            $uri->getAuthority(),
            $uri->getPath(),
            $uri->getQuery(),
            $uri->getFragment()
        ));
    }

    /**
     * Renvoie la sortie de cette requête au client.
     * C'est ce qu'il attendait !
     */
    protected function sendResponse()
    {
        $this->totalTime = $this->timer->getElapsedTime('total_execution');
        Services::emitter()->emit(
            Services::toolbar()->prepare($this->getPerformanceStats(), $this->request, $this->response)
        );
    }

    protected function emitResponse()
    {
        $this->gatherOutput();
        $this->sendResponse();
    }

    /**
     * Construit une reponse adequate en fonction du retour du controleur
     *
     * @param mixed $returned
     */
    protected function formatResponse(ResponseInterface $response, $returned): ResponseInterface
    {
        if ($returned instanceof ResponseInterface) {
            return $returned;
        }

        if ($returned instanceof Responsable) {
            return $returned->toResponse($this->request);
        }

        if (is_object($returned)) {
            if (method_exists($returned, '__toString')) {
                $returned = $returned->__toString();
            } elseif (method_exists($returned, 'toArray')) {
                $returned = $returned->toArray();
            } elseif (method_exists($returned, 'toJSON')) {
                $returned = $returned->toJSON();
            } else {
                $returned = (array) $returned;
            }
        }

        if (is_array($returned)) {
            $returned = Helpers::collect($returned);
            $response = $response->withHeader('Content-Type', 'application/json');
        }

        try {
            $response = $response->withBody(to_stream($returned));
        } catch (InvalidArgumentException $e) {

        }

        return $response;

    }

    /**
     * Initialise le gestionnaire de middleware
     */
    protected function initMiddlewareQueue(): void
    {
        $this->middleware = new Middleware($this->response, $this->determinePath());

        $this->middleware->append($this->spoofRequestMethod());
        $this->middleware->register($this->request);
    }

    protected function outputBufferingStart(): void
    {
        $this->bufferLevel = ob_get_level();

        ob_start();
    }

    protected function outputBufferingEnd(): string
    {
        $buffer = '';

        while (ob_get_level() > $this->bufferLevel) {
            $buffer .= ob_get_contents();
            ob_end_clean();
        }

        return $buffer;
    }

    /**
     * Modifie l'objet de requête pour utiliser une méthode différente
     * si une variable POST appelée _method est trouvée.
     */
    private function spoofRequestMethod(): callable
    {
        return static function (ServerRequestInterface $request, ResponseInterface $response, callable $next) {
            $post = $request->getParsedBody();

            // Ne fonctionne qu'avec les formulaires POST
            if (strtoupper($request->getMethod()) === 'POST' && ! empty($post['_method'])) {
                // Accepte seulement PUT, PATCH, DELETE
                if (in_array(strtoupper($post['_method']), ['PUT', 'PATCH', 'DELETE'], true)) {
                    $request = $request->withMethod($post['_method']);
                }
            }

            return $next($request, $response);
        };
    }

    private function bootApp(): callable
    {
        return function (ServerRequestInterface $request, ResponseInterface $response, callable $next): ResponseInterface {
            try {
                $returned = $this->startController($request, $response);

                // Closure controller has run in startController().
                if (! is_callable($this->controller)) {
                    $controller = $this->createController($request, $response);

                    if (! method_exists($controller, '_remap') && ! is_callable([$controller, $this->method], false)) {
                        throw PageNotFoundException::methodNotFound($this->method);
                    }

                    // Y'a t-il un evenement "post_controller_constructor"
                    $this->event->trigger('post_controller_constructor');

                    $returned = $this->runController($controller);
                } else {
                    $this->timer->stop('controller_constructor');
                    $this->timer->stop('controller');
                }

                $this->event->trigger('post_system');

                return $this->formatResponse($response, $returned);
            } catch (ValidationException $e) {
                return $this->formatValidationResponse($e, $request, $response);
            }
        };
    }

    /**
     * Formattage des erreurs de validation
     */
    private function formatValidationResponse(ValidationException $e, ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
    {
        $code = $e->getCode();
        if (empty($errors = $e->getErrors())) {
            $errors = [$e->getMessage()];
        }

        if (is_string($this->controller)) {
            if (strtoupper($request->getMethod()) === 'POST') {
                if (is_subclass_of($this->controller, BaseController::class)) {
                    return Services::redirection()->back()->withInput()->withErrors($errors)->withStatus($code);
                }
                if (is_subclass_of($this->controller, RestController::class)) {
                    return $this->formatResponse($response->withStatus($code), [
                        'success' => false,
                        'code'    => $code,
                        'errors'  => $errors,
                    ]);
                }
            }
        } elseif (strtoupper($request->getMethod()) === 'POST') {
            return Services::redirection()->back()->withInput()->withErrors($errors)->withStatus($code);
        }

        throw $e;
    }
}

blitz-php / framework

Push — main ( c1749a...759bea )

Dispatcher::formatValidationResponse() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
