Mouf\Mvc\Splash\Routers\SplashDefaultRouter::__invoke()

Complexity

Conditions	16
Paths	440

Size

Total Lines	132
Code Lines	73

Duplication

Lines	0
Ratio	0 %

Importance

Changes	8
Bugs	0	Features	0

<?php
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $out = null)
    {
        try {
            $this->purgeExpiredRoutes();

            $urlNodesCacheItem = $this->cachePool->getItem('splashUrlNodes');
            if (!$urlNodesCacheItem->isHit()) {
                // No value in cache, let's get the URL nodes
                $urlsList = $this->getSplashActionsList();
                $urlNodes = $this->generateUrlNode($urlsList);
                $urlNodesCacheItem->set($urlNodes);
                $this->cachePool->save($urlNodesCacheItem);
            }

            $urlNodes = $urlNodesCacheItem->get();
            /* @var $urlNodes SplashUrlNode */

            $request_path = $request->getUri()->getPath();

            $pos = strpos($request_path, $this->rootUrl);
            if ($pos === false) {
                throw new SplashException('Error: the prefix of the web application "'.$this->rootUrl.'" was not found in the URL. The application must be misconfigured. Check the ROOT_URL parameter in your config.php file at the root of your project. It should have the same value as the RewriteBase parameter in your .htaccess file. Requested URL : "'.$request_path.'"');
            }

            $tailing_url = substr($request_path, $pos + strlen($this->rootUrl));

            $splashRoute = $urlNodes->walk($tailing_url, $request);

            if ($splashRoute === null) {
                // No route found. Let's try variants with or without trailing / if we are in a GET.
                if ($request->getMethod() === 'GET') {
                    // If there is a trailing /, let's remove it and retry
                    if (strrpos($tailing_url, '/') === strlen($tailing_url) - 1) {
                        $url = substr($tailing_url, 0, -1);
                        $splashRoute = $urlNodes->walk($url, $request);
                    } else {
                        $url = $tailing_url.'/';
                        $splashRoute = $urlNodes->walk($url, $request);
                    }

                    if ($splashRoute !== null) {
                        // If a route does match, let's make a redirect.
                        return new RedirectResponse($this->rootUrl.$url);
                    }
                }

                $this->log->debug('Found no route for URL {url}.', [
                    'url' => $request_path,
                ]);

                // No route found, let's pass control to the next middleware.
                if ($out !== null) {
                    return $out($request, $response);
                } else {
                    throw PageNotFoundException::create($tailing_url);
                }
            }

            // Is the route still valid according to the cache?
            if (!$splashRoute->isCacheValid()) {
                // The route is invalid! Let's purge the cache and retry!
                $this->purgeUrlsCache();
                return $this($request, $response, $out);
            }


            $controller = $this->container->get($splashRoute->getControllerInstanceName());
            $action = $splashRoute->getMethodName();

            $this->log->debug('Routing URL {url} to controller instance {controller} and action {action}', [
                'url' => $request_path,
                'controller' => $splashRoute->getControllerInstanceName(),
                'action' => $action,
            ]);


            $filters = $splashRoute->getFilters();



            $middlewareCaller = function(ServerRequestInterface $request, ResponseInterface $response) use ($controller, $action, $splashRoute, $splashRoute) {

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

                // Let's recreate a new context object (because request can be modified by the filters)
                $context = new SplashRequestContext($request);
                $context->setUrlParameters($splashRoute->getFilledParameters());
                // Let's pass everything to the controller:
                $args = $this->parameterFetcherRegistry->toArguments($context, $splashRoute->getParameters());

The method toArguments cannot be called on $this->parameterFetcherRegistry (of type array<integer,object<Mouf\Mvc\Splash\Services\ParameterFetcher>>).

                $response = SplashUtils::buildControllerResponse(
                    function () use ($controller, $action, $args) {
                        return $controller->$action(...$args);
                    },
                    $this->mode,
                    $this->debug
                );

                return $response;
            };

            // Apply filters
            for ($i = count($filters) - 1; $i >= 0; --$i) {
                $filter = $filters[$i];
                $middlewareCaller = function(ServerRequestInterface $request, ResponseInterface $response) use ($middlewareCaller, $filter) {
                    return $filter($request, $response, $middlewareCaller, $this->container);
                };
            }


            $response = $middlewareCaller($request, $response);

            return $response;
        } catch (BadRequestException $e) {
            if ($this->http400Handler !== null) {
                return $this->http400Handler->badRequest($e, $request);
            } else {
                throw $e;
            }
        } catch (PageNotFoundException $e) {
            if ($this->http404Handler !== null) {
                return $this->http404Handler->pageNotFound($request);
            } else {
                throw $e;
            }
        } catch (\Throwable $t) {
            if ($this->http500Handler !== null) {
                return $this->http500Handler->serverError($t, $request);
            } else {
                throw $t;
            }
        }
    }