spiral / framework

src/Router/tests/UriTest.php

Spacing +2 added lines, -2 removed lines

@@ -106,7 +106,7 @@ 
 
         $uri = $router->uri('test:id', [
             'id' => 100,
-            'title' => new class implements \Stringable {
+            'title' => new class implements \Stringable{
                 public function __toString()
                 {
                     return 'hello-world';
@@ -201,7 +201,7 @@ 
         $uriHandler->setStrict(true);
         $route = $route->withUriHandler($uriHandler);
 
-        self::assertSame($expected, (string) $route->uri($params));
+        self::assertSame($expected, (string)$route->uri($params));
     }
 
     #[DataProvider('provideSegmentInDifferentLanguages')]

src/Router/src/UriHandler.php

Spacing +38 added lines, -38 removed lines

@@ -60,7 +60,7 @@ 
         private readonly UriFactoryInterface $uriFactory,
         ?SlugifyInterface $slugify = null,
         ?RoutePatternRegistryInterface $patternRegistry = null,
-    ) {
+    ){
         $this->patternRegistry = $patternRegistry ?? new DefaultPatternRegistry();
 
         $slugify ??= new Slugify();
@@ -130,7 +130,7 @@ 
      */
     public function withBasePath(string $basePath): self
     {
-        if (!\str_ends_with($basePath, '/')) {
+        if (!\str_ends_with($basePath, '/')){
             $basePath .= '/';
         }
 
@@ -180,12 +180,12 @@ 
      */
     public function match(UriInterface $uri, array $defaults): ?array
     {
-        if (!$this->isCompiled()) {
+        if (!$this->isCompiled()){
             $this->compile();
         }
 
         $matches = [];
-        if (!\preg_match($this->compiled, $this->fetchTarget($uri), $matches)) {
+        if (!\preg_match($this->compiled, $this->fetchTarget($uri), $matches)){
             return null;
         }
 
@@ -202,7 +202,7 @@ 
      */
     public function uri(iterable $parameters = [], array $defaults = []): UriInterface
     {
-        if (!$this->isCompiled()) {
+        if (!$this->isCompiled()){
             $this->compile();
         }
 
@@ -214,13 +214,13 @@ 
 
         $required = \array_keys($this->constrains);
         $parametersToCheck = $parameters;
-        if ($this->strict) {
+        if ($this->strict){
             $required = \array_unique([...$this->requiredOptions, ...$required]);
             $parametersToCheck = \array_filter($parametersToCheck);
         }
 
         $missingParameters = \array_diff($required, \array_keys($parametersToCheck));
-        if ($missingParameters !== []) {
+        if ($missingParameters !== []){
             throw new UriHandlerException(
                 \sprintf(
                     \count($missingParameters) === 1
@@ -235,7 +235,7 @@ 
         $path = $this->interpolate($this->template, $parameters);
 
         //Uri with added base path and prefix
-        $uri = $this->uriFactory->createUri(($this->matchHost ? '' : $this->basePath) . \trim($path, '/'));
+        $uri = $this->uriFactory->createUri(($this->matchHost ? '' : $this->basePath).\trim($path, '/'));
 
         return empty($query) ? $uri : $uri->withQuery(\http_build_query($query));
     }
@@ -250,23 +250,23 @@ 
         $allowed = \array_keys($this->options);
 
         $result = [];
-        foreach ($parameters as $key => $parameter) {
-            if (\is_int($key) && isset($allowed[$key])) {
+        foreach ($parameters as $key => $parameter){
+            if (\is_int($key) && isset($allowed[$key])){
                 // this segment fetched keys from given parameters either by name or by position
                 $key = $allowed[$key];
-            } elseif (!\array_key_exists($key, $this->options) && \is_array($parameters)) {
+            } elseif (!\array_key_exists($key, $this->options) && \is_array($parameters)){
                 // all additional parameters given in array form can be glued to query string
                 $query[$key] = $parameter;
                 continue;
             }
 
             // String must be normalized here
-            if (\is_string($parameter) && !\preg_match('/^[a-z\-_0-9]+$/i', $parameter)) {
+            if (\is_string($parameter) && !\preg_match('/^[a-z\-_0-9]+$/i', $parameter)){
                 $result[$key] = ($this->pathSegmentEncoder)($parameter);
                 continue;
             }
 
-            $result[$key] = (string) $parameter;
+            $result[$key] = (string)$parameter;
         }
 
         return $result;
@@ -279,13 +279,13 @@ 
     {
         $path = $uri->getPath();
 
-        if (empty($path) || $path[0] !== '/') {
-            $path = '/' . $path;
+        if (empty($path) || $path[0] !== '/'){
+            $path = '/'.$path;
         }
 
-        if ($this->matchHost) {
-            $uriString = $uri->getHost() . $path;
-        } else {
+        if ($this->matchHost){
+            $uriString = $uri->getHost().$path;
+        }else{
             $uriString = \substr($path, \strlen($this->basePath)) ?: '';
         }
 
@@ -300,7 +300,7 @@ 
      */
     private function compile(): void
     {
-        if ($this->pattern === null) {
+        if ($this->pattern === null){
             throw new UriHandlerException('Unable to compile UriHandler, pattern is not set');
         }
 
@@ -310,19 +310,19 @@ 
         // 1) Build full pattern
         $prefix = \rtrim($this->getPrefix(), '/ ');
         $pattern = \ltrim($this->pattern, '/ ');
-        $pattern = $prefix . '/' . $pattern;
+        $pattern = $prefix.'/'.$pattern;
         $pattern = \rtrim(\ltrim($pattern, ':/'), '/');
 
         // correct [/ first occurrence]
-        if (\str_starts_with($pattern, '[/')) {
-            $pattern = '[' . \substr($pattern, 2);
+        if (\str_starts_with($pattern, '[/')){
+            $pattern = '['.\substr($pattern, 2);
         }
 
         // 2) Extract variables from the pattern
-        if (\preg_match_all('/<(\w+):?(.*?)?>/', $pattern, $matches)) {
+        if (\preg_match_all('/<(\w+):?(.*?)?>/', $pattern, $matches)){
             $variables = \array_combine($matches[1], $matches[2]);
 
-            foreach ($variables as $key => $segment) {
+            foreach ($variables as $key => $segment){
                 $segment = $this->prepareSegment($key, $segment);
                 $replaces[\sprintf('<%s>', $key)] = \sprintf('(?P<%s>%s)', $key, $segment);
                 $options[] = $key;
@@ -334,14 +334,14 @@ 
         $options = \array_fill_keys($options, null);
 
         // 3) Validate constraints
-        foreach ($this->constrains as $key => $value) {
-            if ($value instanceof Autofill) {
+        foreach ($this->constrains as $key => $value){
+            if ($value instanceof Autofill){
                 // only forces value replacement, not required to be presented as parameter
                 continue;
             }
 
             // If a constraint references a param that doesn't appear in the pattern or defaults
-            if (!\array_key_exists($key, $options) && !isset($this->defaults[$key])) {
+            if (!\array_key_exists($key, $options) && !isset($this->defaults[$key])){
                 throw new ConstrainException(
                     \sprintf(
                         'Route `%s` does not define routing parameter `<%s>`.',
@@ -353,12 +353,12 @@ 
         }
 
         // 4) Compile your final regex pattern
-        $this->compiled = '/^' . \strtr($template, $replaces + self::PATTERN_REPLACES) . '$/iu';
+        $this->compiled = '/^'.\strtr($template, $replaces + self::PATTERN_REPLACES).'$/iu';
         $this->template = \stripslashes(\str_replace('?', '', $template));
         $this->options = $options;
 
         // 5) Mark which parameters are required vs. optional
-        if ($this->strict) {
+        if ($this->strict){
             $this->requiredOptions = $this->findRequiredOptions($pattern, \array_keys($options));
         }
     }
@@ -380,20 +380,20 @@ 
         $pos = 0;
         $length = \strlen($pattern);
 
-        while ($pos < $length) {
+        while ($pos < $length){
             $char = $pattern[$pos];
 
             // We enter an optional segment
-            if ($char === '[') {
+            if ($char === '['){
                 \array_push($stack, '[');
             } // We exit an optional segment
-            elseif ($char === ']') {
+            elseif ($char === ']'){
                 \array_pop($stack);
             } // We see a parameter like <id> or <action:\d+>
-            elseif ($char === '<') {
+            elseif ($char === '<'){
                 // Find the closing '>'
                 $endPos = \strpos($pattern, '>', $pos);
-                if ($endPos === false) {
+                if ($endPos === false){
                     break;
                 }
 
@@ -404,7 +404,7 @@ 
                 $varName = \explode(':', $varPart)[0];
 
                 // If we are inside a bracket, that var is optional
-                if ($stack !== []) {
+                if ($stack !== []){
                     $optionalVars[] = $varName;
                 }
 
@@ -429,9 +429,9 @@ 
     private function interpolate(string $string, array $values): string
     {
         $replaces = [];
-        foreach ($values as $key => $value) {
+        foreach ($values as $key => $value){
             $replaces[\sprintf('<%s>', $key)] = match (true) {
-                $value instanceof \Stringable || \is_scalar($value) => (string) $value,
+                $value instanceof \Stringable || \is_scalar($value) => (string)$value,
                 default => '',
             };
         }
@@ -451,7 +451,7 @@ 
                 '|',
                 \array_map(fn(string $segment): string => $this->filterSegment($segment), $this->constrains[$name]),
             ),
-            default => $this->filterSegment((string) $this->constrains[$name])
+            default => $this->filterSegment((string)$this->constrains[$name])
         };
     }