Yarhon\RouteGuardBundle\Security\Http\RequestContextFactory::createContext()

Complexity

Conditions	9
Paths	1

Size

Total Lines	65
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	29
CRAP Score	9

Importance

Changes

0

<?php
    public function createContext(RouteContextInterface $routeContext)
    {
        $urlGenerator = $this->urlGenerator;
        $urlGeneratorContext = $this->urlGenerator->getContext();

        $generateUrlClosure = function () use ($routeContext, $urlGenerator) {
            static $generated;

            if (null === $generated) {
                if (!($routeContext instanceof GeneratedUrlAwareInterface) || null === $routeContext->getReferenceType()) {
                    $generated = $urlGenerator->generate($routeContext->getName(), $routeContext->getParameters(), UrlGeneratorInterface::ABSOLUTE_PATH);
                } else {
                    $referenceType = $routeContext->getReferenceType();

                    // We need to parse path and host from the generated url, that depends on reference type.
                    // When using ABSOLUTE_URL or NETWORK_PATH, generated url will contain both path and host.
                    //
                    // When using ABSOLUTE_PATH or RELATIVE_PATH, generated url will contain only path.
                    // If route has some specific host assigned, the UrlGenerator will force reference type to
                    // ABSOLUTE_URL or NETWORK_PATH, that would produce url with host.
                    // So, with ABSOLUTE_PATH or RELATIVE_PATH, if generated url does not contains host, we can be sure
                    // that the host is the "current" host, and grab it from UrlGenerator context.
                    // Finally, with RELATIVE_PATH we can't simply determine path (absolute), so we force generation to
                    // ABSOLUTE_URL, and don't save the generated url.

                    if (UrlGeneratorInterface::RELATIVE_PATH === $referenceType) {
                        $referenceType = UrlGeneratorInterface::ABSOLUTE_URL;
                    }

                    $generated = $urlGenerator->generate($routeContext->getName(), $routeContext->getParameters(), $referenceType);

                    if (UrlGeneratorInterface::RELATIVE_PATH !== $routeContext->getReferenceType()) {
                        $routeContext->setGeneratedUrl($generated);
                    }
                }
            }

            return $generated;
        };

        $pathInfoClosure = function () use ($generateUrlClosure, $urlGeneratorContext) {
            $url = $generateUrlClosure();
            $pathInfo = parse_url($url, PHP_URL_PATH);
            $pathInfo = substr($pathInfo, strlen($urlGeneratorContext->getBaseUrl()));

            // See \Symfony\Component\HttpFoundation\Request::preparePathInfo
            if (false === $pathInfo || '' === $pathInfo) {
                $pathInfo = '/';
            }

            return $pathInfo;
        };

        $hostClosure = function () use ($generateUrlClosure, $urlGeneratorContext) {
            $url = $generateUrlClosure();
            $host = parse_url($url, PHP_URL_HOST) ?: $urlGeneratorContext->getHost();

            return $host;
        };

        $request = $this->requestStack->getCurrentRequest();

        $requestContext = new RequestContext($pathInfoClosure, $hostClosure, $routeContext->getMethod(), $request->getClientIp());

        return $requestContext;
    }