Merge pull request #285 from clue-labs/backslashes

clue · web-flow · commit 72e8ce868df7 · 2025-12-14T20:49:17.000+01:00
Improve performance by using global namespace prefix for all functions
diff --git a/src/AccessLogHandler.php b/src/AccessLogHandler.php
@@ -94,14 +94,14 @@ private function logWhenClosed(ServerRequestInterface $request, ResponseInterfac
         if ($body instanceof ReadableStreamInterface && $body->isReadable()) {
             $size = 0;
             $body->on('data', function (string $chunk) use (&$size) {
-                $size += strlen($chunk);
+                $size += \strlen($chunk);
             });
 
             $body->on('close', function () use (&$size, $request, $response, $start) {
                 $this->log($request, $response, $size, $this->now() - $start);
             });
         } else {
-            $this->log($request, $response, $body->getSize() ?? strlen((string) $body), $this->now() - $start);
+            $this->log($request, $response, $body->getSize() ?? \strlen((string) $body), $this->now() - $start);
         }
     }
 
@@ -122,19 +122,19 @@ private function log(ServerRequestInterface $request, ResponseInterface $respons
         $this->logger->log(
             ($request->getAttribute('remote_addr') ?? $request->getServerParams()['REMOTE_ADDR'] ?? '-') . ' ' .
             '"' . $this->escape($method) . ' ' . $this->escape($request->getRequestTarget()) . ' HTTP/' . $request->getProtocolVersion() . '" ' .
-            $status . ' ' . $responseSize . ' ' . sprintf('%.3F', $time < 0 ? 0 : $time)
+            $status . ' ' . $responseSize . ' ' . \sprintf('%.3F', $time < 0 ? 0 : $time)
         );
     }
 
     private function escape(string $s): string
     {
-        return (string) preg_replace_callback('/[\x00-\x1F\x7F-\xFF"\\\\]+/', function (array $m) {
-            return str_replace('%', '\x', rawurlencode($m[0]));
+        return (string) \preg_replace_callback('/[\x00-\x1F\x7F-\xFF"\\\\]+/', function (array $m) {
+            return \str_replace('%', '\x', \rawurlencode($m[0]));
         }, $s);
     }
 
     private function now(): float
     {
-        return $this->hasHighResolution ? hrtime(true) * 1e-9 : microtime(true);
+        return $this->hasHighResolution ? \hrtime(true) * 1e-9 : \microtime(true);
     }
 }
diff --git a/src/App.php b/src/App.php
@@ -290,7 +290,7 @@ public function __invoke(ServerRequestInterface $request): ResponseInterface
         if ($response instanceof PromiseInterface) {
             /** @throws void */
             $response = await($response);
-            assert($response instanceof ResponseInterface);
+            \assert($response instanceof ResponseInterface);
         }
 
         return $response;
@@ -308,14 +308,14 @@ public function __invoke(ServerRequestInterface $request): ResponseInterface
     private function handleRequest(ServerRequestInterface $request)
     {
         $response = ($this->handler)($request);
-        assert($response instanceof ResponseInterface || $response instanceof PromiseInterface || $response instanceof \Generator);
+        \assert($response instanceof ResponseInterface || $response instanceof PromiseInterface || $response instanceof \Generator);
 
         if ($response instanceof \Generator) {
             if ($response->valid()) {
                 $response = $this->coroutine($response);
             } else {
                 $response = $response->getReturn();
-                assert($response instanceof ResponseInterface);
+                \assert($response instanceof ResponseInterface);
             }
         }
 
@@ -336,7 +336,7 @@ private function coroutine(\Generator $generator): PromiseInterface
             }
 
             $promise = $generator->current();
-            assert($promise instanceof PromiseInterface);
+            \assert($promise instanceof PromiseInterface);
 
             $promise->then(function ($value) use ($generator, $next) {
                 $generator->send($value);
diff --git a/src/Container.php b/src/Container.php
@@ -94,7 +94,7 @@ public function callable(string $class): callable
             // Check `$handler` references a class name that is callable, i.e. has an `__invoke()` method.
             // This initial version is intentionally limited to checking the method name only.
             // A follow-up version will likely use reflection to check request handler argument types.
-            if (!is_callable($handler)) {
+            if (!\is_callable($handler)) {
                 throw new \Error(
                     'Request handler ' . \explode("\0", $class)[0] . ' has no public __invoke() method'
                 );
@@ -115,7 +115,7 @@ public function callable(string $class): callable
      */
     public function getEnv(string $name): ?string
     {
-        assert(\preg_match('/^[A-Z][A-Z0-9_]+$/', $name) === 1);
+        \assert(\preg_match('/^[A-Z][A-Z0-9_]+$/', $name) === 1);
 
         if ($this->container instanceof ContainerInterface && $this->container->has($name)) {
             $value = $this->container->get($name);
@@ -180,7 +180,7 @@ public function getErrorHandler(): ErrorHandler
      */
     private function loadObject(string $name, int $depth = 64) /*: object (PHP 7.2+) */
     {
-        assert(\is_array($this->container));
+        \assert(\is_array($this->container));
 
         if (\array_key_exists($name, $this->container)) {
             if (\is_string($this->container[$name])) {
@@ -226,13 +226,13 @@ private function loadObject(string $name, int $depth = 64) /*: object (PHP 7.2+)
                 );
             }
 
-            assert($this->container[$name] instanceof $name);
+            \assert($this->container[$name] instanceof $name);
 
             return $this->container[$name];
         }
 
         // Check `$name` references a valid class name that can be autoloaded
-        if (!\class_exists($name, true) && !interface_exists($name, false) && !trait_exists($name, false)) {
+        if (!\class_exists($name, true) && !\interface_exists($name, false) && !\trait_exists($name, false)) {
             throw new \Error('Class ' . $name . ' not found');
         }
 
@@ -287,7 +287,7 @@ private function loadParameter(\ReflectionParameter $parameter, int $depth, bool
             throw new \Error(self::parameterError($parameter, $for) . ' is recursive');
         }
 
-        assert(\is_array($this->container));
+        \assert(\is_array($this->container));
         $type = $parameter->getType();
 
         // abort for union types (PHP 8.0+) and intersection types (PHP 8.1+)
@@ -306,7 +306,7 @@ private function loadParameter(\ReflectionParameter $parameter, int $depth, bool
         } // @codeCoverageIgnoreEnd
 
         // load container variables if parameter name is known
-        assert($type === null || $type instanceof \ReflectionNamedType);
+        \assert($type === null || $type instanceof \ReflectionNamedType);
         if ($allowVariables && $this->hasVariable($parameter->getName())) {
             $value = $this->loadVariable($parameter->getName(), $depth);
 
@@ -355,13 +355,13 @@ private function hasVariable(string $name): bool
      */
     private function loadVariable(string $name, int $depth = 64) /*: object|string|int|float|bool|null (PHP 8.0+) */
     {
-        assert($this->hasVariable($name));
-        assert(\is_array($this->container) || !$this->container->has($name));
+        \assert($this->hasVariable($name));
+        \assert(\is_array($this->container) || !$this->container->has($name));
 
         if (\is_array($this->container) && ($this->container[$name] ?? null) instanceof \Closure) {
             // build list of factory parameters based on parameter types
             $factory = $this->container[$name];
-            assert($factory instanceof \Closure);
+            \assert($factory instanceof \Closure);
             $closure = new \ReflectionFunction($factory);
             $params = $this->loadFunctionParams($closure, $depth - 1, true, '$' . $name);
 
@@ -378,17 +378,17 @@ private function loadVariable(string $name, int $depth = 64) /*: object|string|i
         } elseif (\is_array($this->container) && \array_key_exists($name, $this->container)) {
             $value = $this->container[$name];
         } elseif (isset($_ENV[$name])) {
-            assert(\is_string($_ENV[$name]));
+            \assert(\is_string($_ENV[$name]));
             $value = $_ENV[$name];
         } elseif (isset($_SERVER[$name])) {
-            assert(\is_string($_SERVER[$name]));
+            \assert(\is_string($_SERVER[$name]));
             $value = $_SERVER[$name];
         } else {
             $value = \getenv($name);
-            assert($this->useProcessEnv && $value !== false);
+            \assert($this->useProcessEnv && $value !== false);
         }
 
-        assert(\is_object($value) || \is_scalar($value) || $value === null);
+        \assert(\is_object($value) || \is_scalar($value) || $value === null);
         return $value;
     }
 
diff --git a/src/FilesystemHandler.php b/src/FilesystemHandler.php
@@ -64,7 +64,7 @@ public function __construct(string $root)
     public function __invoke(ServerRequestInterface $request): ResponseInterface
     {
         $local = $request->getAttribute('path', '');
-        assert(\is_string($local));
+        \assert(\is_string($local));
         $path = \rtrim($this->root . '/' . $local, '/');
 
         // local path should not contain "./", "../", "//" or null bytes or start with slash
diff --git a/src/Io/FiberHandler.php b/src/Io/FiberHandler.php
@@ -40,13 +40,13 @@ public function __invoke(ServerRequestInterface $request, callable $next)
         $deferred = null;
         $fiber = new \Fiber(function () use ($request, $next, &$deferred) {
             $response = $next($request);
-            assert($response instanceof ResponseInterface || $response instanceof PromiseInterface || $response instanceof \Generator);
+            \assert($response instanceof ResponseInterface || $response instanceof PromiseInterface || $response instanceof \Generator);
 
             // if the next request handler returns immediately, the fiber can terminate immediately without using a Deferred
             // if the next request handler suspends the fiber, we only reach this point after resuming the fiber, so the code below will have assigned a Deferred
             /** @var ?Deferred<ResponseInterface> $deferred */
             if ($deferred !== null) {
-                assert($response instanceof ResponseInterface);
+                \assert($response instanceof ResponseInterface);
                 $deferred->resolve($response);
             }
 
diff --git a/src/Io/LogStreamHandler.php b/src/Io/LogStreamHandler.php
@@ -85,7 +85,7 @@ public function log(string $message): void
         $prefix = \date('Y-m-d H:i:s', (int) $time) . \sprintf('.%03d ', (int) (($time - (int) $time) * 1e3));
 
         $ret = \fwrite($this->stream, $prefix . $message . \PHP_EOL);
-        assert(\is_int($ret));
+        \assert(\is_int($ret));
     }
 
     private function isAbsolutePath(string $path): bool
diff --git a/src/Io/MiddlewareHandler.php b/src/Io/MiddlewareHandler.php
@@ -15,7 +15,7 @@ class MiddlewareHandler
     /** @param list<callable> $handlers */
     public function __construct(array $handlers)
     {
-        assert(count($handlers) >= 2);
+        \assert(\count($handlers) >= 2);
 
         $this->handlers = $handlers;
     }
diff --git a/src/Io/RouteHandler.php b/src/Io/RouteHandler.php
@@ -52,7 +52,7 @@ public function map(array $methods, string $route, $handler, ...$handlers): void
             $handlers = [$handler];
         }
 
-        $last = key($handlers);
+        $last = \key($handlers);
         $container = $this->container;
         foreach ($handlers as $i => $handler) {
             if ($handler instanceof Container && $i !== $last) {
@@ -66,7 +66,7 @@ public function map(array $methods, string $route, $handler, ...$handlers): void
         }
 
         /** @var non-empty-array<callable> $handlers */
-        $handler = \count($handlers) > 1 ? new MiddlewareHandler(array_values($handlers)) : \reset($handlers);
+        $handler = \count($handlers) > 1 ? new MiddlewareHandler(\array_values($handlers)) : \reset($handlers);
         $this->routeDispatcher = null;
         $this->routeCollector->addRoute($methods, $route, $handler);
     }
@@ -88,15 +88,15 @@ public function __invoke(ServerRequestInterface $request)
         }
 
         $routeInfo = $this->routeDispatcher->dispatch($request->getMethod(), $target);
-        assert(\is_array($routeInfo) && isset($routeInfo[0]));
+        \assert(\is_array($routeInfo) && isset($routeInfo[0]));
 
         // happy path: matching route found, assign route attributes and invoke request handler
         if ($routeInfo[0] === \FastRoute\Dispatcher::FOUND) {
             $handler = $routeInfo[1];
             $vars = $routeInfo[2];
 
             foreach ($vars as $key => $value) {
-                $request = $request->withAttribute($key, rawurldecode($value));
+                $request = $request->withAttribute($key, \rawurldecode($value));
             }
 
             return $handler($request);
@@ -108,8 +108,8 @@ public function __invoke(ServerRequestInterface $request)
         }
 
         // unexpected request method for route: report error `405 Method Not Allowed`
-        assert($routeInfo[0] === \FastRoute\Dispatcher::METHOD_NOT_ALLOWED);
-        assert(\is_array($routeInfo[1]) && \count($routeInfo[1]) > 0);
+        \assert($routeInfo[0] === \FastRoute\Dispatcher::METHOD_NOT_ALLOWED);
+        \assert(\is_array($routeInfo[1]) && \count($routeInfo[1]) > 0);
 
         return $this->errorHandler->requestMethodNotAllowed($routeInfo[1]);
     }
diff --git a/src/Io/SapiHandler.php b/src/Io/SapiHandler.php
@@ -54,7 +54,7 @@ public function requestFromGlobals(): ServerRequestInterface
         } else {
             foreach ($_SERVER as $key => $value) {
                 if (\strpos($key, 'HTTP_') === 0) {
-                    $key = str_replace(' ', '-', \ucwords(\strtolower(\str_replace('_', ' ', \substr($key, 5)))));
+                    $key = \str_replace(' ', '-', \ucwords(\strtolower(\str_replace('_', ' ', \substr($key, 5)))));
                     $headers[$key] = $value;
 
                     if ($host === null && $key === 'Host') {
@@ -73,15 +73,15 @@ public function requestFromGlobals(): ServerRequestInterface
             $url = (($_SERVER['HTTPS'] ?? null) === 'on' ? 'https://' : 'http://') . $target;
         }
 
-        $body = file_get_contents('php://input');
-        assert(\is_string($body));
+        $body = \file_get_contents('php://input');
+        \assert(\is_string($body));
 
         $request = new ServerRequest(
             $_SERVER['REQUEST_METHOD'] ?? 'GET',
             $url,
             $headers,
             $body,
-            substr($_SERVER['SERVER_PROTOCOL'] ?? 'http/1.1', 5),
+            \substr($_SERVER['SERVER_PROTOCOL'] ?? 'http/1.1', 5),
             $_SERVER
         );
         if ($host === null) {
@@ -121,22 +121,22 @@ public function sendResponse(ResponseInterface $response): void
 
         // remove default "Content-Type" header set by PHP (default_mimetype)
         if (!$response->hasHeader('Content-Type')) {
-            header('Content-Type:');
-            header_remove('Content-Type');
+            \header('Content-Type:');
+            \header_remove('Content-Type');
         }
 
         // send all headers without applying default "; charset=utf-8" set by PHP (default_charset)
-        $old = ini_get('default_charset');
-        assert(\is_string($old));
-        ini_set('default_charset', '');
+        $old = \ini_get('default_charset');
+        \assert(\is_string($old));
+        \ini_set('default_charset', '');
         foreach ($response->getHeaders() as $name => $values) {
             foreach ($values as $value) {
-                header($name . ': ' . $value, false);
+                \header($name . ': ' . $value, false);
             }
         }
-        ini_set('default_charset', $old);
+        \ini_set('default_charset', $old);
 
-        header($_SERVER['SERVER_PROTOCOL'] . ' ' . $status . ' ' . $response->getReasonPhrase());
+        \header($_SERVER['SERVER_PROTOCOL'] . ' ' . $status . ' ' . $response->getReasonPhrase());
 
         if (($_SERVER['REQUEST_METHOD'] ?? '') === 'HEAD' || $status === Response::STATUS_NO_CONTENT || $status === Response::STATUS_NOT_MODIFIED) {
             $body->close();
@@ -145,8 +145,8 @@ public function sendResponse(ResponseInterface $response): void
 
         if ($body instanceof ReadableStreamInterface) {
             // try to disable nginx buffering (http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_buffering)
-            if (isset($_SERVER['SERVER_SOFTWARE']) && strpos($_SERVER['SERVER_SOFTWARE'], 'nginx') === 0) {
-                header('X-Accel-Buffering: no');
+            if (isset($_SERVER['SERVER_SOFTWARE']) && \strpos($_SERVER['SERVER_SOFTWARE'], 'nginx') === 0) {
+                \header('X-Accel-Buffering: no');
             }
 
             // clear output buffer to show streaming output (default in cli-server)
@@ -157,7 +157,7 @@ public function sendResponse(ResponseInterface $response): void
             // flush data whenever stream reports one data chunk
             $body->on('data', function ($chunk) {
                 echo $chunk;
-                flush();
+                \flush();
             });
         } else {
             echo $body;

Original file line number	Diff line number	Diff line change
`@@ -94,14 +94,14 @@ private function logWhenClosed(ServerRequestInterface $request, ResponseInterfac`
`94`	`94`	`if ($body instanceof ReadableStreamInterface && $body->isReadable()) {`
`95`	`95`	`$size = 0;`
`96`	`96`	`$body->on('data', function (string $chunk) use (&$size) {`
`97`		`- $size += strlen($chunk);`
	`97`	`+ $size += \strlen($chunk);`
`98`	`98`	`});`
`99`	`99`
`100`	`100`	`$body->on('close', function () use (&$size, $request, $response, $start) {`
`101`	`101`	`$this->log($request, $response, $size, $this->now() - $start);`
`102`	`102`	`});`
`103`	`103`	`} else {`
`104`		`- $this->log($request, $response, $body->getSize() ?? strlen((string) $body), $this->now() - $start);`
	`104`	`+ $this->log($request, $response, $body->getSize() ?? \strlen((string) $body), $this->now() - $start);`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`@@ -122,19 +122,19 @@ private function log(ServerRequestInterface $request, ResponseInterface $respons`
`122`	`122`	`$this->logger->log(`
`123`	`123`	`($request->getAttribute('remote_addr') ?? $request->getServerParams()['REMOTE_ADDR'] ?? '-') . ' ' .`
`124`	`124`	`'"' . $this->escape($method) . ' ' . $this->escape($request->getRequestTarget()) . ' HTTP/' . $request->getProtocolVersion() . '" ' .`
`125`		`- $status . ' ' . $responseSize . ' ' . sprintf('%.3F', $time < 0 ? 0 : $time)`
	`125`	`+ $status . ' ' . $responseSize . ' ' . \sprintf('%.3F', $time < 0 ? 0 : $time)`
`126`	`126`	`);`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`private function escape(string $s): string`
`130`	`130`	`{`
`131`		`- return (string) preg_replace_callback('/[\x00-\x1F\x7F-\xFF"\\\\]+/', function (array $m) {`
`132`		`- return str_replace('%', '\x', rawurlencode($m[0]));`
	`131`	`+ return (string) \preg_replace_callback('/[\x00-\x1F\x7F-\xFF"\\\\]+/', function (array $m) {`
	`132`	`+ return \str_replace('%', '\x', \rawurlencode($m[0]));`
`133`	`133`	`}, $s);`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`private function now(): float`
`137`	`137`	`{`
`138`		`- return $this->hasHighResolution ? hrtime(true) * 1e-9 : microtime(true);`
	`138`	`+ return $this->hasHighResolution ? \hrtime(true) * 1e-9 : \microtime(true);`
`139`	`139`	`}`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -290,7 +290,7 @@ public function __invoke(ServerRequestInterface $request): ResponseInterface`
`290`	`290`	`if ($response instanceof PromiseInterface) {`
`291`	`291`	`/** @throws void */`
`292`	`292`	`$response = await($response);`
`293`		`- assert($response instanceof ResponseInterface);`
	`293`	`+ \assert($response instanceof ResponseInterface);`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`return $response;`
`@@ -308,14 +308,14 @@ public function __invoke(ServerRequestInterface $request): ResponseInterface`
`308`	`308`	`private function handleRequest(ServerRequestInterface $request)`
`309`	`309`	`{`
`310`	`310`	`$response = ($this->handler)($request);`
`311`		`- assert($response instanceof ResponseInterface \|\| $response instanceof PromiseInterface \|\| $response instanceof \Generator);`
	`311`	`+ \assert($response instanceof ResponseInterface \|\| $response instanceof PromiseInterface \|\| $response instanceof \Generator);`
`312`	`312`
`313`	`313`	`if ($response instanceof \Generator) {`
`314`	`314`	`if ($response->valid()) {`
`315`	`315`	`$response = $this->coroutine($response);`
`316`	`316`	`} else {`
`317`	`317`	`$response = $response->getReturn();`
`318`		`- assert($response instanceof ResponseInterface);`
	`318`	`+ \assert($response instanceof ResponseInterface);`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
`@@ -336,7 +336,7 @@ private function coroutine(\Generator $generator): PromiseInterface`
`336`	`336`	`}`
`337`	`337`
`338`	`338`	`$promise = $generator->current();`
`339`		`- assert($promise instanceof PromiseInterface);`
	`339`	`+ \assert($promise instanceof PromiseInterface);`
`340`	`340`
`341`	`341`	`$promise->then(function ($value) use ($generator, $next) {`
`342`	`342`	`$generator->send($value);`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ public function __construct(string $root)`
`64`	`64`	`public function __invoke(ServerRequestInterface $request): ResponseInterface`
`65`	`65`	`{`
`66`	`66`	`$local = $request->getAttribute('path', '');`
`67`		`- assert(\is_string($local));`
	`67`	`+ \assert(\is_string($local));`
`68`	`68`	`$path = \rtrim($this->root . '/' . $local, '/');`
`69`	`69`
`70`	`70`	`// local path should not contain "./", "../", "//" or null bytes or start with slash`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public function log(string $message): void`
`85`	`85`	`$prefix = \date('Y-m-d H:i:s', (int) $time) . \sprintf('.%03d ', (int) (($time - (int) $time) * 1e3));`
`86`	`86`
`87`	`87`	`$ret = \fwrite($this->stream, $prefix . $message . \PHP_EOL);`
`88`		`- assert(\is_int($ret));`
	`88`	`+ \assert(\is_int($ret));`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`private function isAbsolutePath(string $path): bool`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ class MiddlewareHandler`
`15`	`15`	`/** @param list<callable> $handlers */`
`16`	`16`	`public function __construct(array $handlers)`
`17`	`17`	`{`
`18`		`- assert(count($handlers) >= 2);`
	`18`	`+ \assert(\count($handlers) >= 2);`
`19`	`19`
`20`	`20`	`$this->handlers = $handlers;`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public function map(array $methods, string $route, $handler, ...$handlers): void`
`52`	`52`	`$handlers = [$handler];`
`53`	`53`	`}`
`54`	`54`
`55`		`- $last = key($handlers);`
	`55`	`+ $last = \key($handlers);`
`56`	`56`	`$container = $this->container;`
`57`	`57`	`foreach ($handlers as $i => $handler) {`
`58`	`58`	`if ($handler instanceof Container && $i !== $last) {`
`@@ -66,7 +66,7 @@ public function map(array $methods, string $route, $handler, ...$handlers): void`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`/** @var non-empty-array<callable> $handlers */`
`69`		`- $handler = \count($handlers) > 1 ? new MiddlewareHandler(array_values($handlers)) : \reset($handlers);`
	`69`	`+ $handler = \count($handlers) > 1 ? new MiddlewareHandler(\array_values($handlers)) : \reset($handlers);`
`70`	`70`	`$this->routeDispatcher = null;`
`71`	`71`	`$this->routeCollector->addRoute($methods, $route, $handler);`
`72`	`72`	`}`
`@@ -88,15 +88,15 @@ public function __invoke(ServerRequestInterface $request)`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`$routeInfo = $this->routeDispatcher->dispatch($request->getMethod(), $target);`
`91`		`- assert(\is_array($routeInfo) && isset($routeInfo[0]));`
	`91`	`+ \assert(\is_array($routeInfo) && isset($routeInfo[0]));`
`92`	`92`
`93`	`93`	`// happy path: matching route found, assign route attributes and invoke request handler`
`94`	`94`	`if ($routeInfo[0] === \FastRoute\Dispatcher::FOUND) {`
`95`	`95`	`$handler = $routeInfo[1];`
`96`	`96`	`$vars = $routeInfo[2];`
`97`	`97`
`98`	`98`	`foreach ($vars as $key => $value) {`
`99`		`- $request = $request->withAttribute($key, rawurldecode($value));`
	`99`	`+ $request = $request->withAttribute($key, \rawurldecode($value));`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`return $handler($request);`
`@@ -108,8 +108,8 @@ public function __invoke(ServerRequestInterface $request)`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	// unexpected request method for route: report error `405 Method Not Allowed`
`111`		`- assert($routeInfo[0] === \FastRoute\Dispatcher::METHOD_NOT_ALLOWED);`
`112`		`- assert(\is_array($routeInfo[1]) && \count($routeInfo[1]) > 0);`
	`111`	`+ \assert($routeInfo[0] === \FastRoute\Dispatcher::METHOD_NOT_ALLOWED);`
	`112`	`+ \assert(\is_array($routeInfo[1]) && \count($routeInfo[1]) > 0);`
`113`	`113`
`114`	`114`	`return $this->errorHandler->requestMethodNotAllowed($routeInfo[1]);`
`115`	`115`	`}`