spiral / framework

src/AuthHttp/src/Transport/CookieTransport.php

Braces +9 added lines, -4 removed lines

@@ -85,7 +85,8 @@ 
     ): Response {
         /** @var CookieQueue $cookieQueue */
         $cookieQueue = $request->getAttribute(CookieQueue::ATTRIBUTE);
-        if ($cookieQueue === null) {
+        if ($cookieQueue === null)
+        {
             return $response->withAddedHeader(
                 'Set-Cookie',
                 Cookie::create(
@@ -101,9 +102,12 @@ 
             );
         }
 
-        if ($tokenID === null) {
+        if ($tokenID === null)
+        {
             $cookieQueue->delete($this->cookie);
-        } else {
+        }
+        else
+        {
             $cookieQueue->set(
                 $this->cookie,
                 $tokenID,
@@ -134,7 +138,8 @@ 
      */
     private function getLifetime(\DateTimeInterface $expiresAt = null): ?int
     {
-        if ($expiresAt === null) {
+        if ($expiresAt === null)
+        {
             return null;
         }
 

src/Stempler/src/Traverser.php

Braces +48 added lines, -24 removed lines

@@ -19,7 +19,8 @@ 
 
     public function __construct(array $visitors = [])
     {
-        foreach ($visitors as $visitor) {
+        foreach ($visitors as $visitor)
+        {
             $this->addVisitor($visitor);
         }
     }
@@ -34,8 +35,10 @@ 
 
     public function removeVisitor(VisitorInterface $visitor): void
     {
-        foreach ($this->visitors as $index => $added) {
-            if ($added === $visitor) {
+        foreach ($this->visitors as $index => $added)
+        {
+            if ($added === $visitor)
+            {
                 unset($this->visitors[$index]);
                 break;
             }
@@ -56,22 +59,27 @@ 
         $context ??= new VisitorContext();
 
         $ctx = clone $context;
-        foreach ($nodes as $index => $node) {
-            if ($this->stopTraversal) {
+        foreach ($nodes as $index => $node)
+        {
+            if ($this->stopTraversal)
+            {
                 break;
             }
 
             $traverseChildren = true;
             $breakVisitorID = null;
 
-            if ($node instanceof NodeInterface) {
+            if ($node instanceof NodeInterface)
+            {
                 $ctx = $context->withNode($node);
             }
 
-            foreach ($this->visitors as $visitorID => $visitor) {
+            foreach ($this->visitors as $visitorID => $visitor)
+            {
                 $result = $visitor->enterNode($node, $ctx);
 
-                switch (true) {
+                switch (true)
+                {
                     case $result === null:
                         break;
 
@@ -101,17 +109,21 @@ 
             }
 
             // sub nodes
-            if ($traverseChildren && $node instanceof NodeInterface) {
+            if ($traverseChildren && $node instanceof NodeInterface)
+            {
                 $nodes[$index] = $this->traverseNode($node, $ctx);
-                if ($this->stopTraversal) {
+                if ($this->stopTraversal)
+                {
                     break;
                 }
             }
 
-            foreach ($this->visitors as $visitorID => $visitor) {
+            foreach ($this->visitors as $visitorID => $visitor)
+            {
                 $result = $visitor->leaveNode($node, $ctx);
 
-                switch (true) {
+                switch (true)
+                {
                     case $result === null:
                         break;
 
@@ -133,7 +145,8 @@ 
                         );
                 }
 
-                if ($breakVisitorID === $visitorID) {
+                if ($breakVisitorID === $visitorID)
+                {
                     break;
                 }
             }
@@ -148,18 +161,22 @@ 
     private function traverseNode(NodeInterface $node, VisitorContext $context): NodeInterface
     {
         $ctx = clone $context;
-        foreach ($node as $name => $_) {
+        foreach ($node as $name => $_)
+        {
             $_child = &$node->$name;
-            if (\is_array($_child)) {
+            if (\is_array($_child))
+            {
                 $_child = $this->traverse($_child, $ctx);
-                if ($this->stopTraversal) {
+                if ($this->stopTraversal)
+                {
                     break;
                 }
 
                 continue;
             }
 
-            if (!$_child instanceof NodeInterface) {
+            if (!$_child instanceof NodeInterface)
+            {
                 continue;
             }
 
@@ -168,9 +185,11 @@ 
             $traverseChildren = true;
             $breakVisitorID = null;
 
-            foreach ($this->visitors as $visitorID => $visitor) {
+            foreach ($this->visitors as $visitorID => $visitor)
+            {
                 $result = $visitor->enterNode($_child, $ctx);
-                switch (true) {
+                switch (true)
+                {
                     case $result === null:
                         break;
 
@@ -198,17 +217,21 @@ 
                 }
             }
 
-            if ($traverseChildren) {
+            if ($traverseChildren)
+            {
                 $_child = $this->traverseNode($_child, $ctx);
-                if ($this->stopTraversal) {
+                if ($this->stopTraversal)
+                {
                     break;
                 }
             }
 
-            foreach ($this->visitors as $visitorID => $visitor) {
+            foreach ($this->visitors as $visitorID => $visitor)
+            {
                 $result = $visitor->leaveNode($_child, $ctx);
 
-                switch (true) {
+                switch (true)
+                {
                     case $result === null:
                         break;
 
@@ -226,7 +249,8 @@ 
                         );
                 }
 
-                if ($breakVisitorID === $visitorID) {
+                if ($breakVisitorID === $visitorID)
+                {
                     break;
                 }
             }

src/Config/src/Patch/Prepend.php

Braces +10 added lines, -4 removed lines

@@ -25,15 +25,21 @@
 
     public function patch(array $config): array
     {
-        try {
+        try
+        {
             $_target = &$this->dotGet($config, $this->position);
 
-            if ($this->key !== null) {
+            if ($this->key !== null)
+            {
                 $_target = \array_merge([$this->key => $this->value], $_target);
-            } else {
+            }
+            else
+            {
                 \array_unshift($_target, $this->value);
             }
-        } catch (DotNotFoundException $e) {
+        }
+        catch (DotNotFoundException $e)
+        {
             throw new PatchException($e->getMessage(), $e->getCode(), $e);
         }
 

src/Config/src/Patch/Set.php

Braces +5 added lines, -2 removed lines

@@ -24,10 +24,13 @@
 
     public function patch(array $config): array
     {
-        try {
+        try
+        {
             $_target = &$this->dotGet($config, $this->key);
             $_target = $this->value;
-        } catch (DotNotFoundException $e) {
+        }
+        catch (DotNotFoundException $e)
+        {
             throw new PatchException($e->getMessage(), $e->getCode(), $e);
         }
 

src/Filters/src/Model/Schema/AttributeMapper.php

Braces +33 added lines, -14 removed lines

@@ -37,40 +37,55 @@ 
         $setters = [];
         $class = new \ReflectionClass($filter);
 
-        foreach ($class->getProperties() as $property) {
+        foreach ($class->getProperties() as $property)
+        {
             /** @var object $attribute */
-            foreach ($this->reader->getPropertyMetadata($property) as $attribute) {
-                if ($attribute instanceof AbstractInput) {
+            foreach ($this->reader->getPropertyMetadata($property) as $attribute)
+            {
+                if ($attribute instanceof AbstractInput)
+                {
                     $this->setValue($filter, $property, $attribute->getValue($input, $property));
                     $schema[$property->getName()] = $attribute->getSchema($property);
-                } elseif ($attribute instanceof NestedFilter) {
+                }
+                elseif ($attribute instanceof NestedFilter)
+                {
                     $prefix = $attribute->prefix ?? $property->name;
-                    try {
+                    try
+                    {
                         $value = $this->provider->createFilter(
                             $attribute->class,
                             $input->withPrefix($prefix)
                         );
 
                         $this->setValue($filter, $property, $value);
-                    } catch (ValidationException $e) {
+                    }
+                    catch (ValidationException $e)
+                    {
                         $errors[$prefix] = $e->errors;
                     }
 
                     $schema[$property->getName()] = $attribute->getSchema($property);
-                } elseif ($attribute instanceof NestedArray) {
+                }
+                elseif ($attribute instanceof NestedArray)
+                {
                     $values = $attribute->getValue($input, $property);
                     $propertyValues = [];
 
                     $prefix = $attribute->input->key ?? $attribute->prefix ?? $property->getName();
 
-                    if (\is_array($values)) {
-                        foreach (\array_keys($values) as $key) {
-                            try {
+                    if (\is_array($values))
+                    {
+                        foreach (\array_keys($values) as $key)
+                        {
+                            try
+                            {
                                 $propertyValues[$key] = $this->provider->createFilter(
                                     $attribute->class,
                                     $input->withPrefix($prefix . '.' . $key)
                                 );
-                            } catch (ValidationException $e) {
+                            }
+                            catch (ValidationException $e)
+                            {
                                 $errors[$property->getName()][$key] = $e->errors;
                             }
                         }
@@ -78,7 +93,9 @@ 
 
                     $this->setValue($filter, $property, $propertyValues);
                     $schema[$property->getName()] = [$attribute->class, $prefix . '.*'];
-                } elseif ($attribute instanceof Setter) {
+                }
+                elseif ($attribute instanceof Setter)
+                {
                     $setters[$property->getName()][] = $attribute;
                 }
             }
@@ -89,13 +106,15 @@ 
 
     private function setValue(FilterInterface $filter, \ReflectionProperty $property, mixed $value): void
     {
-        if ($value === null) {
+        if ($value === null)
+        {
             return;
         }
 
         $setters = $this->reader->getPropertyMetadata($property, Setter::class);
 
-        foreach ($setters as $setter) {
+        foreach ($setters as $setter)
+        {
             $value = $setter->updateValue($value);
         }
 

src/Router/src/RouteCollection.php

Braces +8 added lines, -4 removed lines

@@ -16,7 +16,8 @@ 
 
     public function __clone()
     {
-        foreach ($this->routes as $name => $route) {
+        foreach ($this->routes as $name => $route)
+        {
             $this->routes[$name] = clone $route;
         }
     }
@@ -92,7 +93,8 @@ 
      */
     public function remove(string|array $name)
     {
-        foreach ((array) $name as $n) {
+        foreach ((array) $name as $n)
+        {
             unset($this->routes[$n]);
         }
     }
@@ -104,7 +106,8 @@ 
      */
     public function addCollection(self $collection)
     {
-        foreach ($collection->all() as $name => $route) {
+        foreach ($collection->all() as $name => $route)
+        {
             $this->routes[$name] = $route;
         }
     }
@@ -120,7 +123,8 @@ 
      */
     public function group(string $group)
     {
-        foreach ($this->routes as $route) {
+        foreach ($this->routes as $route)
+        {
             $route->group($group);
         }
     }

src/Router/src/GroupRegistry.php

Braces +4 added lines, -2 removed lines

@@ -28,7 +28,8 @@ 
      */
     public function getGroup(string $name): RouteGroup
     {
-        if (!isset($this->groups[$name])) {
+        if (!isset($this->groups[$name]))
+        {
             $this->groups[$name] = $this->factory->make(RouteGroup::class);
         }
 
@@ -60,7 +61,8 @@ 
      */
     public function registerRoutes(RouterInterface $router): void
     {
-        foreach ($this->groups as $group) {
+        foreach ($this->groups as $group)
+        {
             $group->register($router, $this->factory);
         }
     }

src/Tokenizer/src/Listener/CachedClassesLoader.php

Braces +6 added lines, -3 removed lines

@@ -25,7 +25,8 @@ 
         $targets = \iterator_to_array($this->parseAttributes($listener));
 
         // If there are no targets, then listener can't be cached.
-        if ($targets === []) {
+        if ($targets === [])
+        {
             return false;
         }
 
@@ -34,11 +35,13 @@ 
         // We decided to load classes for each target separately.
         // It allows us to cache classes for each target separately and if we reuse the
         // same target in multiple listeners, we will not have to load classes for the same target.
-        foreach ($targets as $target) {
+        foreach ($targets as $target)
+        {
             $cacheKey = (string)$target;
 
             $classes = $this->readCache ? $this->memory->loadData($cacheKey) : null;
-            if ($classes === null) {
+            if ($classes === null)
+            {
                 $this->memory->saveData(
                     $cacheKey,
                     $classes = $this->locator->getClasses($target),

src/Core/src/Internal/Factory.php

Braces +122 added lines, -52 removed lines

@@ -64,13 +64,15 @@ 
      */
     public function make(string $alias, array $parameters = [], string $context = null): mixed
     {
-        if (!isset($this->state->bindings[$alias])) {
+        if (!isset($this->state->bindings[$alias]))
+        {
             return $this->resolveWithoutBinding($alias, $parameters, $context);
         }
 
         $avoidCache = $parameters !== [];
         $binding = $this->state->bindings[$alias];
-        try {
+        try
+        {
             $this->tracer->push(
                 false,
                 action: 'resolve from binding',
@@ -81,8 +83,10 @@ 
             );
             $this->tracer->push(true);
 
-            if (\is_object($binding)) {
-                if ($binding::class === WeakReference::class) {
+            if (\is_object($binding))
+            {
+                if ($binding::class === WeakReference::class)
+                {
                     return $this->resolveWeakReference($binding, $alias, $context, $parameters);
                 }
 
@@ -96,7 +100,8 @@ 
             }
 
             $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context);
-            if (\is_string($binding)) {
+            if (\is_string($binding))
+            {
                 $ctx->class = $binding;
                 return $binding === $alias
                     ? $this->autowire($ctx, $parameters)
@@ -104,18 +109,24 @@ 
                     : $this->make($binding, $parameters, $context);
             }
 
-            if ($binding[1] === true) {
+            if ($binding[1] === true)
+            {
                 $ctx->singleton = true;
             }
             unset($this->state->bindings[$alias]);
-            try {
+            try
+            {
                 return $binding[0] === $alias
                     ? $this->autowire($ctx, $parameters)
                     : $this->evaluateBinding($ctx, $binding[0], $parameters);
-            } finally {
+            }
+            finally
+            {
                 $this->state->bindings[$alias] ??= $binding;
             }
-        } finally {
+        }
+        finally
+        {
             $this->tracer->pop(true);
             $this->tracer->pop(false);
         }
@@ -129,19 +140,24 @@ 
     ): ?object {
         $avoidCache = $parameters !== [];
 
-        if (($avoidCache || $binding->get() === null) && \class_exists($alias)) {
-            try {
+        if (($avoidCache || $binding->get() === null) && \class_exists($alias))
+        {
+            try
+            {
                 $this->tracer->push(false, alias: $alias, source: WeakReference::class, context: $context);
 
                 $object = $this->createInstance(
                     new Ctx(alias: $alias, class: $alias, parameter: $context),
                     $parameters,
                 );
-                if ($avoidCache) {
+                if ($avoidCache)
+                {
                     return $object;
                 }
                 $binding = $this->state->bindings[$alias] = WeakReference::create($object);
-            } catch (\Throwable) {
+            }
+            catch (\Throwable)
+            {
                 throw new ContainerException(
                     $this->tracer->combineTraceMessage(
                         \sprintf(
@@ -151,7 +167,9 @@ 
                         )
                     )
                 );
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop();
             }
         }
@@ -163,18 +181,25 @@ 
     {
         $parent = $this->scope->getParent();
 
-        if ($parent !== null) {
-            try {
+        if ($parent !== null)
+        {
+            try
+            {
                 $this->tracer->push(false, ...[
                     'current scope' => $this->scope->getScopeName(),
                     'jump to parent scope' => $this->scope->getParentScope()->getScopeName(),
                 ]);
                 return $parent->make($alias, $parameters, $context);
-            } catch (BadScopeException $e) {
-                if ($this->scope->getScopeName() !== $e->getScope()) {
+            }
+            catch (BadScopeException $e)
+            {
+                if ($this->scope->getScopeName() !== $e->getScope())
+                {
                     throw $e;
                 }
-            } catch (ContainerExceptionInterface $e) {
+            }
+            catch (ContainerExceptionInterface $e)
+            {
                 $className = match (true) {
                     $e instanceof NotFoundException => NotFoundException::class,
                     default => ContainerException::class,
@@ -183,19 +208,24 @@ 
                     'Can\'t resolve `%s`.',
                     $alias,
                 )), previous: $e);
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop(false);
             }
         }
 
         $this->tracer->push(false, action: 'autowire', alias: $alias, context: $context);
-        try {
+        try
+        {
             //No direct instructions how to construct class, make is automatically
             return $this->autowire(
                 new Ctx(alias: $alias, class: $alias, parameter: $context),
                 $parameters,
             );
-        } finally {
+        }
+        finally
+        {
             $this->tracer->pop(false);
         }
     }
@@ -245,16 +275,25 @@ 
         mixed $target,
         array $arguments,
     ): mixed {
-        if (\is_string($target)) {
+        if (\is_string($target))
+        {
             // Reference
             $instance = $this->make($target, $arguments, $ctx->parameter);
-        } else {
-            if ($target instanceof Autowire) {
+        }
+        else
+        {
+            if ($target instanceof Autowire)
+            {
                 $instance = $target->resolve($this, $arguments);
-            } else {
-                try {
+            }
+            else
+            {
+                try
+                {
                     $instance = $this->invoker->invoke($target, $arguments);
-                } catch (NotCallableException $e) {
+                }
+                catch (NotCallableException $e)
+                {
                     throw new ContainerException(
                         $this->tracer->combineTraceMessage(\sprintf('Invalid binding for `%s`.', $ctx->alias)),
                         $e->getCode(),
@@ -264,10 +303,12 @@ 
             }
 
             // Check scope name
-            if (\is_object($instance)) {
+            if (\is_object($instance))
+            {
                 $ctx->reflection = new \ReflectionClass($instance);
                 $scopeName = ($ctx->reflection->getAttributes(ScopeAttribute::class)[0] ?? null)?->newInstance()->name;
-                if ($scopeName !== null && $scopeName !== $this->scope->getScopeName()) {
+                if ($scopeName !== null && $scopeName !== $this->scope->getScopeName())
+                {
                     throw new BadScopeException($scopeName, $instance::class);
                 }
             }
@@ -296,26 +337,33 @@ 
         array $parameters,
     ): object {
         $class = $ctx->class;
-        try {
+        try
+        {
             $ctx->reflection = $reflection = new \ReflectionClass($class);
-        } catch (\ReflectionException $e) {
+        }
+        catch (\ReflectionException $e)
+        {
             throw new ContainerException($e->getMessage(), $e->getCode(), $e);
         }
 
         // Check scope name
         $scope = ($reflection->getAttributes(ScopeAttribute::class)[0] ?? null)?->newInstance()->name;
-        if ($scope !== null && $scope !== $this->scope->getScopeName()) {
+        if ($scope !== null && $scope !== $this->scope->getScopeName())
+        {
             throw new BadScopeException($scope, $class);
         }
 
         //We have to construct class using external injector when we know exact context
-        if ($parameters === [] && $this->binder->hasInjector($class)) {
+        if ($parameters === [] && $this->binder->hasInjector($class))
+        {
             $injector = $this->state->injectors[$reflection->getName()];
 
-            try {
+            try
+            {
                 $injectorInstance = $this->container->get($injector);
 
-                if (!$injectorInstance instanceof InjectorInterface) {
+                if (!$injectorInstance instanceof InjectorInterface)
+                {
                     throw new InjectionException(
                         \sprintf(
                             "Class '%s' must be an instance of InjectorInterface for '%s'.",
@@ -330,7 +378,8 @@ 
                  * @psalm-suppress RedundantCondition
                  */
                 $instance = $injectorInstance->createInjection($reflection, $ctx->parameter);
-                if (!$reflection->isInstance($instance)) {
+                if (!$reflection->isInstance($instance))
+                {
                     throw new InjectionException(
                         \sprintf(
                             "Invalid injection response for '%s'.",
@@ -340,12 +389,15 @@ 
                 }
 
                 return $instance;
-            } finally {
+            }
+            finally
+            {
                 $this->state->injectors[$reflection->getName()] = $injector;
             }
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable())
+        {
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -358,12 +410,16 @@ 
 
         $constructor = $reflection->getConstructor();
 
-        if ($constructor !== null) {
-            try {
+        if ($constructor !== null)
+        {
+            try
+            {
                 $this->tracer->push(false, action: 'resolve arguments', signature: $constructor);
                 $this->tracer->push(true);
                 $arguments = $this->resolver->resolveArguments($constructor, $parameters);
-            } catch (ValidationException $e) {
+            }
+            catch (ValidationException $e)
+            {
                 throw new ContainerException(
                     $this->tracer->combineTraceMessage(
                         \sprintf(
@@ -373,22 +429,31 @@ 
                         )
                     ),
                 );
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop(true);
                 $this->tracer->pop(false);
             }
-            try {
+            try
+            {
                 // Using constructor with resolved arguments
                 $this->tracer->push(false, call: "$class::__construct", arguments: $arguments);
                 $this->tracer->push(true);
                 $instance = new $class(...$arguments);
-            } catch (\TypeError $e) {
+            }
+            catch (\TypeError $e)
+            {
                 throw new WrongTypeException($constructor, $e);
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop(true);
                 $this->tracer->pop(false);
             }
-        } else {
+        }
+        else
+        {
             // No constructor specified
             $instance = $reflection->newInstance();
         }
@@ -412,13 +477,15 @@ 
         $ctx->reflection ??= new \ReflectionClass($instance);
 
         //Declarative singletons
-        if ($this->isSingleton($ctx)) {
+        if ($this->isSingleton($ctx))
+        {
             $this->state->bindings[$ctx->alias] = $instance;
         }
 
         // Register finalizer
         $finalizer = $this->getFinalizer($ctx, $instance);
-        if ($finalizer !== null) {
+        if ($finalizer !== null)
+        {
             $this->state->finalizers[] = $finalizer;
         }
 
@@ -430,11 +497,13 @@ 
      */
     private function isSingleton(Ctx $ctx): bool
     {
-        if ($ctx->singleton === true) {
+        if ($ctx->singleton === true)
+        {
             return true;
         }
 
-        if ($ctx->reflection->implementsInterface(SingletonInterface::class)) {
+        if ($ctx->reflection->implementsInterface(SingletonInterface::class))
+        {
             return true;
         }
 
@@ -448,7 +517,8 @@ 
          * @var Finalize|null $attribute
          */
         $attribute = ($ctx->reflection->getAttributes(Finalize::class)[0] ?? null)?->newInstance();
-        if ($attribute === null) {
+        if ($attribute === null)
+        {
             return null;
         }