Merge pull request #163 from symfony-cmf/use-context-to-improve-request-reconstruction

use the request context to rebuild the request on matching

Author: dbu

CHANGELOG.md

@@ -1,6 +1,9 @@
 Changelog
 =========
 
+* **2016-01-09**: When ChainRouter::match is used with a RequestMatcher, the
+  Request is now properly rebuilt from the RequestContext if that was set on
+  the ChainRouter.
 * **2014-09-29**: ChainRouter does not require a RouterInterface, as a
   RequestMatcher and UrlGenerator is fine too. Fixed chain router interface to
   not force a RouterInterface.

ChainRouter.php

@@ -180,11 +180,12 @@ private function doMatch($url, Request $request = null)
                 // matching requests is more powerful than matching URLs only, so try that first
                 if ($router instanceof RequestMatcherInterface) {
                     if (empty($requestForMatching)) {
-                        $requestForMatching = Request::create($url);
+                        $requestForMatching = $this->rebuildRequest($url);
                     }
 
                     return $router->matchRequest($requestForMatching);
                 }
+
                 // every router implements the match method
                 return $router->match($url);
             } catch (ResourceNotFoundException $e) {
@@ -249,6 +250,51 @@ public function generate($name, $parameters = array(), $absolute = UrlGeneratorI
         throw new RouteNotFoundException(sprintf('None of the chained routers were able to generate route: %s', $info));
     }
 
+    /**
+     * Rebuild the request object from a URL with the help of the RequestContext.
+     *
+     * If the request context is not set, this simply returns the request object built from $uri.
+     *
+     * @param string $uri
+     *
+     * @return Request
+     */
+    private function rebuildRequest($uri)
+    {
+        if (!$this->context) {
+            return Request::create($uri);
+        }
+
+        $server = array();
+        if ($this->context->getHost()) {
+            $server['SERVER_NAME'] = $this->context->getHost();
+            $server['HTTP_HOST'] = $this->context->getHost();
+        }
+        if ($this->context->getBaseUrl()) {
+            $uri = $this->context->getBaseUrl().$uri;
+            $server['SCRIPT_FILENAME'] = $this->context->getBaseUrl();
+            $server['PHP_SELF'] = $this->context->getBaseUrl();
+        }
+        if ('https' === $this->context->getScheme()) {
+            $server['HTTPS'] = 'on';
+            $server['SERVER_PORT'] = $this->context->getHttpsPort();
+            if (443 !== $this->context->getHttpsPort()) {
+                // this is parsed from the host by symfony request
+                // https://github.com/symfony/symfony/blob/master/src/Symfony/Component/HttpFoundation/Request.php#L971
+                $server['HTTP_HOST'] .= ':'.$this->context->getHttpsPort();
+            }
+        } else {
+            $server['SERVER_PORT'] = $this->context->getHttpPort();
+            if (80 !== $this->context->getHttpPort()) {
+                // this is parsed from the host by symfony request
+                // https://github.com/symfony/symfony/blob/master/src/Symfony/Component/HttpFoundation/Request.php#L971
+                $server['HTTP_HOST'] .= ':'.$this->context->getHttpPort();
+            }
+        }
+
+        return Request::create($uri, $this->context->getMethod(), $this->context->getParameters(), array(), array(), $server);
+    }
+
     private function getErrorMessage($name, $router = null, $parameters = null)
     {
         if ($router instanceof VersatileGeneratorInterface) {

Tests/Routing/ChainRouterTest.php

@@ -309,6 +309,61 @@ public function testMatchWithRequestMatchers()
         $this->assertEquals(array('test'), $result);
     }
 
+    public function provideBaseUrl()
+    {
+        return array(
+            array(''),
+            array('/web'),
+        );
+    }
+
+    /**
+     * Call match on ChainRouter that has RequestMatcher in the chain.
+     *
+     * @dataProvider provideBaseUrl
+     */
+    public function testMatchWithRequestMatchersAndContext($baseUrl)
+    {
+        $url = '/test';
+
+        list($low) = $this->createRouterMocks();
+
+        $high = $this->getMock('Symfony\Cmf\Component\Routing\Tests\Routing\RequestMatcher');
+
+        $high
+            ->expects($this->once())
+            ->method('matchRequest')
+            ->with($this->callback(function (Request $r) use ($url, $baseUrl) {
+                return true === $r->isSecure()
+                    && 'foobar.com' === $r->getHost()
+                    && 4433 === $r->getPort()
+                    && $baseUrl === $r->getBaseUrl()
+                    && $url === $r->getPathInfo()
+                ;
+            }))
+            ->will($this->throwException(new \Symfony\Component\Routing\Exception\ResourceNotFoundException()))
+        ;
+        $low
+            ->expects($this->once())
+            ->method('match')
+            ->with($url)
+            ->will($this->returnValue(array('test')))
+        ;
+
+        $this->router->add($low, 10);
+        $this->router->add($high, 20);
+
+        $requestContext = new RequestContext();
+        $requestContext->setScheme('https');
+        $requestContext->setHost('foobar.com');
+        $requestContext->setHttpsPort(4433);
+        $requestContext->setBaseUrl($baseUrl);
+        $this->router->setContext($requestContext);
+
+        $result = $this->router->match($url);
+        $this->assertEquals(array('test'), $result);
+    }
+
     /**
      * If there is a method not allowed but another router matches, that one is used.
      */