spiral / framework

src/Core/tests/Scope/Stub/LoggerInjector.php

Spacing +1 added lines, -1 removed lines

@@ -13,7 +13,7 @@
 {
     public function __construct(
         private LoggerInterface $logger,
-    ) {
+    ){
     }
 
     public function createInjection(\ReflectionClass $class, ?string $context = null): LoggerInterface

src/Core/tests/InjectableTest.php

Spacing +4 added lines, -4 removed lines

@@ -36,7 +36,7 @@ 
 
     public function testInvalidInjector(): void
     {
-        $excepted = "Class 'Spiral\Tests\Core\Fixtures\InvalidInjector' must be an " .
+        $excepted = "Class 'Spiral\Tests\Core\Fixtures\InvalidInjector' must be an ".
                     "instance of InjectorInterface for 'Spiral\Tests\Core\Fixtures\TestConfig'";
         $this->expectException(InjectionException::class);
         $this->expectExceptionMessage($excepted);
@@ -62,7 +62,7 @@ 
 
     public function testInvalidRuntimeInjector(): void
     {
-        $excepted = "Class 'Spiral\Tests\Core\Fixtures\InvalidInjector' must be an " .
+        $excepted = "Class 'Spiral\Tests\Core\Fixtures\InvalidInjector' must be an ".
             "instance of InjectorInterface for 'Spiral\Tests\Core\Fixtures\TestConfig'";
         $this->expectException(InjectionException::class);
         $this->expectExceptionMessage($excepted);
@@ -99,7 +99,7 @@ 
         $container->bind(ConfigsInterface::class, $configurator);
 
         $configurator->shouldReceive('createInjection')
-            ->with(m::on(static function (ReflectionClass $r) {
+            ->with(m::on(static function (ReflectionClass $r){
                 return $r->getName() === TestConfig::class;
             }), null)
             ->andReturn($expected);
@@ -116,7 +116,7 @@ 
         $container->bind(ConfigsInterface::class, $configurator);
 
         $configurator->shouldReceive('createInjection')
-            ->with(m::on(static function (ReflectionClass $r) {
+            ->with(m::on(static function (ReflectionClass $r){
                 return $r->getName() === TestConfig::class;
             }), 'context')
             ->andReturn($expected);

Braces +4 added lines, -2 removed lines

@@ -99,7 +99,8 @@ 
         $container->bind(ConfigsInterface::class, $configurator);
 
         $configurator->shouldReceive('createInjection')
-            ->with(m::on(static function (ReflectionClass $r) {
+            ->with(m::on(static function (ReflectionClass $r)
+            {
                 return $r->getName() === TestConfig::class;
             }), null)
             ->andReturn($expected);
@@ -116,7 +117,8 @@ 
         $container->bind(ConfigsInterface::class, $configurator);
 
         $configurator->shouldReceive('createInjection')
-            ->with(m::on(static function (ReflectionClass $r) {
+            ->with(m::on(static function (ReflectionClass $r)
+            {
                 return $r->getName() === TestConfig::class;
             }), 'context')
             ->andReturn($expected);

src/Core/tests/ExceptionsTest.php

Spacing +4 added lines, -4 removed lines

@@ -135,9 +135,9 @@ 
     {
         $container = new Container();
 
-        try {
+        try{
             $container->get('invalid');
-        } catch (ContainerException $e) {
+        }catch (ContainerException $e){
             $this->assertSame(
                 <<<MARKDOWN
                 Can't resolve `invalid`: undefined class or binding `invalid`.
@@ -169,9 +169,9 @@ 
     {
         $this->expectException(ContainerException::class);
 
-        try {
+        try{
             $container->get(ClassWithUndefinedDependency::class);
-        } catch (ContainerException $e) {
+        }catch (ContainerException $e){
             self::assertSame($message, $e->getMessage());
 
             throw $e;

Braces +10 added lines, -4 removed lines

@@ -135,9 +135,12 @@ 
     {
         $container = new Container();
 
-        try {
+        try
+        {
             $container->get('invalid');
-        } catch (ContainerException $e) {
+        }
+        catch (ContainerException $e)
+        {
             $this->assertSame(
                 <<<MARKDOWN
                 Can't resolve `invalid`: undefined class or binding `invalid`.
@@ -169,9 +172,12 @@ 
     {
         $this->expectException(ContainerException::class);
 
-        try {
+        try
+        {
             $container->get(ClassWithUndefinedDependency::class);
-        } catch (ContainerException $e) {
+        }
+        catch (ContainerException $e)
+        {
             self::assertSame($message, $e->getMessage());
 
             throw $e;

src/Core/src/Internal/Binder.php

Spacing +1 added lines, -1 removed lines

@@ -28,7 +28,7 @@
 
     public function hasInstance(string $alias): bool
     {
-        if (!$this->container->has($alias)) {
+        if (!$this->container->has($alias)){
             return false;
         }
 

Braces +2 added lines, -1 removed lines

@@ -28,7 +28,8 @@
 
     public function hasInstance(string $alias): bool
     {
-        if (!$this->container->has($alias)) {
+        if (!$this->container->has($alias))
+        {
             return false;
         }
 

src/Core/src/Internal/Tracer/Trace.php

Spacing +8 added lines, -8 removed lines

@@ -19,14 +19,14 @@ 
 
     public function __construct(
         public array $info = [],
-    ) {
+    ){
         $this->alias = $info['alias'] ?? null;
     }
 
     public function __toString(): string
     {
         $info = [];
-        foreach ($this->info as $key => $item) {
+        foreach ($this->info as $key => $item){
             $info[] = "$key: {$this->stringifyValue($item)}";
         }
         return \implode("\n", $info);
@@ -39,8 +39,8 @@ 
             \is_scalar($item) => \var_export($item, true),
             $item instanceof \Closure => $this->renderClosureSignature(new \ReflectionFunction($item)),
             $item instanceof \ReflectionFunctionAbstract => $this->renderClosureSignature($item),
-            $item instanceof \UnitEnum => $item::class . "::$item->name",
-            \is_object($item) => $item instanceof \Stringable ? (string) $item : 'instance of ' . $item::class,
+            $item instanceof \UnitEnum => $item::class."::$item->name",
+            \is_object($item) => $item instanceof \Stringable ? (string)$item : 'instance of '.$item::class,
             \is_array($item) => $this->renderArray($item),
             default => \get_debug_type($item),
         };
@@ -48,14 +48,14 @@ 
 
     private function renderArray(array $array, int $level = 0): string
     {
-        if ($array === []) {
+        if ($array === []){
             return '[]';
         }
-        if ($level >= self::ARRAY_MAX_LEVEL) {
+        if ($level >= self::ARRAY_MAX_LEVEL){
             return 'array';
         }
         $result = [];
-        foreach ($array as $key => $value) {
+        foreach ($array as $key => $value){
             $result[] = \sprintf(
                 '%s: %s',
                 $key,
@@ -66,6 +66,6 @@ 
         }
 
         $pad = \str_repeat('  ', $level);
-        return "[\n  $pad" . \implode(",\n  $pad", $result) . "\n$pad]";
+        return "[\n  $pad".\implode(",\n  $pad", $result)."\n$pad]";
     }
 }

src/Core/src/Internal/Factory.php

Braces +116 added lines, -50 removed lines

@@ -66,17 +66,20 @@ 
      */
     public function make(string $alias, array $parameters = [], string $context = null): mixed
     {
-        if ($parameters === [] && \array_key_exists($alias, $this->state->singletons)) {
+        if ($parameters === [] && \array_key_exists($alias, $this->state->singletons))
+        {
             return $this->state->singletons[$alias];
         }
 
         $binding = $this->state->bindings[$alias] ?? null;
 
-        if ($binding === null) {
+        if ($binding === null)
+        {
             return $this->resolveWithoutBinding($alias, $parameters, $context);
         }
 
-        try {
+        try
+        {
             $this->tracer->push(
                 false,
                 action: 'resolve from binding',
@@ -100,7 +103,9 @@ 
                     ->resolveWeakReference($binding, $alias, $context, $parameters),
                 default => $binding,
             };
-        } finally {
+        }
+        finally
+        {
             $this->state->bindings[$alias] ??= $binding;
             $this->tracer->pop(true);
             $this->tracer->pop(false);
@@ -116,23 +121,29 @@ 
         $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context);
 
         // We have to construct class using external injector when we know exact context
-        if ($arguments !== []) {
+        if ($arguments !== [])
+        {
             // todo factory?
         }
 
         $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);
         }
 
         $injector = $binding->injector;
 
-        try {
+        try
+        {
             $injectorInstance = \is_object($injector) ? $injector : $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'.",
@@ -147,7 +158,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'.",
@@ -157,7 +169,9 @@ 
             }
 
             return $instance;
-        } finally {
+        }
+        finally
+        {
             $this->state->bindings[$reflection->getName()] ??= $binding; //new Injector($injector);
         }
     }
@@ -176,7 +190,8 @@ 
             //Binding is pointing to something else
             : $this->make($binding->alias, $arguments, $context);
 
-        if ($binding->singleton && $arguments === []) {
+        if ($binding->singleton && $arguments === [])
+        {
             $this->state->singletons[$alias] = $result;
         }
 
@@ -217,11 +232,14 @@ 
         array $arguments,
     ): mixed {
         $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context, singleton: $binding->singleton);
-        try {
+        try
+        {
             $instance = $binding::class === \Spiral\Core\Config\Factory::class && $binding->getParametersCount() === 0
                 ? ($binding->factory)()
                 : $this->invoker->invoke($binding->factory, $arguments);
-        } catch (NotCallableException $e) {
+        }
+        catch (NotCallableException $e)
+        {
             throw new ContainerException(
                 $this->tracer->combineTraceMessage(\sprintf('Invalid binding for `%s`.', $ctx->alias)),
                 $e->getCode(),
@@ -240,19 +258,24 @@ 
     ): ?object {
         $avoidCache = $arguments !== [];
 
-        if (($avoidCache || $binding->reference->get() === null) && \class_exists($alias)) {
-            try {
+        if (($avoidCache || $binding->reference->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),
                     $arguments,
                 );
-                if ($avoidCache) {
+                if ($avoidCache)
+                {
                     return $object;
                 }
                 $binding->reference = WeakReference::create($object);
-            } catch (\Throwable) {
+            }
+            catch (\Throwable)
+            {
                 throw new ContainerException(
                     $this->tracer->combineTraceMessage(
                         \sprintf(
@@ -262,7 +285,9 @@ 
                         )
                     )
                 );
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop();
             }
         }
@@ -274,18 +299,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,
@@ -294,19 +326,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);
         }
     }
@@ -357,7 +394,8 @@ 
         // Check scope name
         $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);
         }
 
@@ -384,24 +422,30 @@ 
         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))
+        {
             return $this->resolveInjector($this->state->bindings[$ctx->class], $ctx->class, $ctx->parameter, $parameters);
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable())
+        {
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -414,12 +458,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(
@@ -429,22 +477,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();
         }
@@ -470,13 +527,15 @@ 
         $instance = $this->runInflector($instance);
 
         //Declarative singletons
-        if ($this->isSingleton($ctx)) {
+        if ($this->isSingleton($ctx))
+        {
             $this->state->singletons[$ctx->alias] = $instance;
         }
 
         // Register finalizer
         $finalizer = $this->getFinalizer($ctx, $instance);
-        if ($finalizer !== null) {
+        if ($finalizer !== null)
+        {
             $this->state->finalizers[] = $finalizer;
         }
 
@@ -488,12 +547,14 @@ 
      */
     private function isSingleton(Ctx $ctx): bool
     {
-        if ($ctx->singleton === true) {
+        if ($ctx->singleton === true)
+        {
             return true;
         }
 
         /** @psalm-suppress RedundantCondition https://github.com/vimeo/psalm/issues/9489 */
-        if ($ctx->reflection->implementsInterface(SingletonInterface::class)) {
+        if ($ctx->reflection->implementsInterface(SingletonInterface::class))
+        {
             return true;
         }
 
@@ -507,7 +568,8 @@ 
          * @var Finalize|null $attribute
          */
         $attribute = ($ctx->reflection->getAttributes(Finalize::class)[0] ?? null)?->newInstance();
-        if ($attribute === null) {
+        if ($attribute === null)
+        {
             return null;
         }
 
@@ -521,10 +583,14 @@ 
     {
         $scope = $this->scope;
 
-        while ($scope !== null) {
-            foreach ($this->state->inflectors as $class => $inflectors) {
-                if ($instance instanceof $class) {
-                    foreach ($inflectors as $inflector) {
+        while ($scope !== null)
+        {
+            foreach ($this->state->inflectors as $class => $inflectors)
+            {
+                if ($instance instanceof $class)
+                {
+                    foreach ($inflectors as $inflector)
+                    {
                         $instance = $inflector->getParametersCount() > 1
                             ? $this->invoker->invoke($inflector->inflector, [$instance])
                             : ($inflector->inflector)($instance);

Spacing +57 added lines, -57 removed lines

@@ -66,17 +66,17 @@ 
      */
     public function make(string $alias, array $parameters = [], string $context = null): mixed
     {
-        if ($parameters === [] && \array_key_exists($alias, $this->state->singletons)) {
+        if ($parameters === [] && \array_key_exists($alias, $this->state->singletons)){
             return $this->state->singletons[$alias];
         }
 
         $binding = $this->state->bindings[$alias] ?? null;
 
-        if ($binding === null) {
+        if ($binding === null){
             return $this->resolveWithoutBinding($alias, $parameters, $context);
         }
 
-        try {
+        try{
             $this->tracer->push(
                 false,
                 action: 'resolve from binding',
@@ -100,7 +100,7 @@ 
                     ->resolveWeakReference($binding, $alias, $context, $parameters),
                 default => $binding,
             };
-        } finally {
+        }finally{
             $this->state->bindings[$alias] ??= $binding;
             $this->tracer->pop(true);
             $this->tracer->pop(false);
@@ -112,27 +112,27 @@ 
         string $alias,
         ?string $context,
         array $arguments,
-    ) {
-        $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context);
+    ){
+        $ctx = new Ctx(alias : $alias, class : $alias, parameter : $context);
 
         // We have to construct class using external injector when we know exact context
-        if ($arguments !== []) {
+        if ($arguments !== []){
             // todo factory?
         }
 
         $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);
         }
 
         $injector = $binding->injector;
 
-        try {
+        try{
             $injectorInstance = \is_object($injector) ? $injector : $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'.",
@@ -146,7 +146,7 @@ 
              * @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'.",
@@ -156,7 +156,7 @@ 
             }
 
             return $instance;
-        } finally {
+        }finally{
             $this->state->bindings[$reflection->getName()] ??= $binding; //new Injector($injector);
         }
     }
@@ -169,13 +169,13 @@ 
     ): mixed {
         $result = $binding->alias === $alias
             ? $this->autowire(
-                new Ctx(alias: $alias, class: $binding->alias, parameter: $context, singleton: $binding->singleton),
+                new Ctx(alias : $alias, class : $binding->alias, parameter : $context, singleton : $binding->singleton),
                 $arguments,
             )
             //Binding is pointing to something else
             : $this->make($binding->alias, $arguments, $context);
 
-        if ($binding->singleton && $arguments === []) {
+        if ($binding->singleton && $arguments === []){
             $this->state->singletons[$alias] = $result;
         }
 
@@ -191,7 +191,7 @@ 
         $avoidCache = $arguments !== [];
         return $avoidCache
             ? $this->createInstance(
-                new Ctx(alias: $alias, class: $binding->value::class, parameter: $context),
+                new Ctx(alias : $alias, class : $binding->value::class, parameter : $context),
                 $arguments,
             )
             : $binding->value;
@@ -210,17 +210,17 @@ 
     }
 
     private function resolveFactory(
-        \Spiral\Core\Config\Factory|DeferredFactory $binding,
+        \Spiral\Core\Config\Factory | DeferredFactory $binding,
         string $alias,
         ?string $context,
         array $arguments,
     ): mixed {
-        $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context, singleton: $binding->singleton);
-        try {
+        $ctx = new Ctx(alias : $alias, class : $alias, parameter : $context, singleton : $binding->singleton);
+        try{
             $instance = $binding::class === \Spiral\Core\Config\Factory::class && $binding->getParametersCount() === 0
                 ? ($binding->factory)()
                 : $this->invoker->invoke($binding->factory, $arguments);
-        } catch (NotCallableException $e) {
+        }catch (NotCallableException $e){
             throw new ContainerException(
                 $this->tracer->combineTraceMessage(\sprintf('Invalid binding for `%s`.', $ctx->alias)),
                 $e->getCode(),
@@ -239,19 +239,19 @@ 
     ): ?object {
         $avoidCache = $arguments !== [];
 
-        if (($avoidCache || $binding->reference->get() === null) && \class_exists($alias)) {
-            try {
+        if (($avoidCache || $binding->reference->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),
                     $arguments,
                 );
-                if ($avoidCache) {
+                if ($avoidCache){
                     return $object;
                 }
                 $binding->reference = WeakReference::create($object);
-            } catch (\Throwable) {
+            }catch (\Throwable){
                 throw new ContainerException(
                     $this->tracer->combineTraceMessage(
                         \sprintf(
@@ -261,7 +261,7 @@ 
                         )
                     )
                 );
-            } finally {
+            }finally{
                 $this->tracer->pop();
             }
         }
@@ -273,18 +273,18 @@ 
     {
         $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,
@@ -293,19 +293,19 @@ 
                     '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);
         }
     }
@@ -327,7 +327,7 @@ 
                 &&
                 (isset($this->state->injectors[$ctx->class]) || $this->binder->hasInjector($ctx->class))
         ))
-        ) {
+        ){
             throw new NotFoundException($this->tracer->combineTraceMessage(\sprintf(
                 'Can\'t resolve `%s`: undefined class or binding `%s`.',
                 $this->tracer->getRootAlias(),
@@ -356,7 +356,7 @@ 
         // Check scope name
         $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);
         }
 
@@ -383,24 +383,24 @@ 
         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)){
             return $this->resolveInjector($this->state->bindings[$ctx->class], $ctx->class, $ctx->parameter, $parameters);
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable()){
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -413,12 +413,12 @@ 
 
         $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(
@@ -428,22 +428,22 @@ 
                         )
                     ),
                 );
-            } 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();
         }
@@ -461,13 +461,13 @@ 
         $instance = $this->runInflector($instance);
 
         //Declarative singletons
-        if ($this->isSingleton($ctx)) {
+        if ($this->isSingleton($ctx)){
             $this->state->singletons[$ctx->alias] = $instance;
         }
 
         // Register finalizer
         $finalizer = $this->getFinalizer($ctx, $instance);
-        if ($finalizer !== null) {
+        if ($finalizer !== null){
             $this->state->finalizers[] = $finalizer;
         }
 
@@ -479,12 +479,12 @@ 
      */
     private function isSingleton(Ctx $ctx): bool
     {
-        if ($ctx->singleton === true) {
+        if ($ctx->singleton === true){
             return true;
         }
 
         /** @psalm-suppress RedundantCondition https://github.com/vimeo/psalm/issues/9489 */
-        if ($ctx->reflection->implementsInterface(SingletonInterface::class)) {
+        if ($ctx->reflection->implementsInterface(SingletonInterface::class)){
             return true;
         }
 
@@ -498,7 +498,7 @@ 
          * @var Finalize|null $attribute
          */
         $attribute = ($ctx->reflection->getAttributes(Finalize::class)[0] ?? null)?->newInstance();
-        if ($attribute === null) {
+        if ($attribute === null){
             return null;
         }
 
@@ -512,10 +512,10 @@ 
     {
         $scope = $this->scope;
 
-        while ($scope !== null) {
-            foreach ($this->state->inflectors as $class => $inflectors) {
-                if ($instance instanceof $class) {
-                    foreach ($inflectors as $inflector) {
+        while ($scope !== null){
+            foreach ($this->state->inflectors as $class => $inflectors){
+                if ($instance instanceof $class){
+                    foreach ($inflectors as $inflector){
                         $instance = $inflector->getParametersCount() > 1
                             ? $this->invoker->invoke($inflector->inflector, [$instance])
                             : ($inflector->inflector)($instance);

src/Core/src/Internal/Resolver.php

Spacing +35 added lines, -35 removed lines

@@ -52,7 +52,7 @@ 
     ): array {
         $state = new ResolvingState($reflection, $parameters);
 
-        foreach ($reflection->getParameters() as $parameter) {
+        foreach ($reflection->getParameters() as $parameter){
             $this->resolveParameter($parameter, $state, $validate)
             or
             throw new ArgumentResolvingException($reflection, $parameter->getName());
@@ -66,47 +66,47 @@ 
         $positional = true;
         $variadic = false;
         $parameters = $reflection->getParameters();
-        if (\count($parameters) === 0) {
+        if (\count($parameters) === 0){
             return;
         }
 
         $parameter = null;
-        while (\count($parameters) > 0 || \count($arguments) > 0) {
+        while (\count($parameters) > 0 || \count($arguments) > 0){
             // get related argument value
             $key = \key($arguments);
 
             // For a variadic parameter it's no sense - named or positional argument will be sent
             // But you can't send positional argument after named in any case
-            if (\is_int($key) && !$positional) {
+            if (\is_int($key) && !$positional){
                 throw new PositionalArgumentException($reflection, $key);
             }
 
             $positional = $positional && \is_int($key);
 
-            if (!$variadic) {
+            if (!$variadic){
                 $parameter = \array_shift($parameters);
                 $variadic = $parameter?->isVariadic() ?? false;
             }
 
-            if ($parameter === null) {
+            if ($parameter === null){
                 throw new UnknownParameterException($reflection, $key);
             }
             $name = $parameter->getName();
 
-            if (($positional || $variadic) && $key !== null) {
+            if (($positional || $variadic) && $key !== null){
                 /** @psalm-suppress ReferenceReusedFromConfusingScope */
                 $value = \array_shift($arguments);
-            } elseif ($key === null || !\array_key_exists($name, $arguments)) {
-                if ($parameter->isOptional()) {
+            } elseif ($key === null || !\array_key_exists($name, $arguments)){
+                if ($parameter->isOptional()){
                     continue;
                 }
                 throw new MissingRequiredArgumentException($reflection, $name);
-            } else {
+            }else{
                 $value = &$arguments[$name];
                 unset($arguments[$name]);
             }
 
-            if (!$this->validateValueToParameter($parameter, $value)) {
+            if (!$this->validateValueToParameter($parameter, $value)){
                 throw new InvalidArgumentException($reflection, $name);
             }
         }
@@ -114,7 +114,7 @@ 
 
     private function validateValueToParameter(ReflectionParameter $parameter, mixed $value): bool
     {
-        if (!$parameter->hasType() || ($parameter->allowsNull() && $value === null)) {
+        if (!$parameter->hasType() || ($parameter->allowsNull() && $value === null)){
             return true;
         }
         $type = $parameter->getType();
@@ -125,17 +125,17 @@ 
             $type instanceof ReflectionIntersectionType => [false, $type->getTypes()],
         };
 
-        foreach ($types as $t) {
+        foreach ($types as $t){
             \assert($t instanceof ReflectionNamedType);
-            if (!$this->validateValueNamedType($t, $value)) {
+            if (!$this->validateValueNamedType($t, $value)){
                 // If it is TypeIntersection
-                if ($or) {
+                if ($or){
                     continue;
                 }
                 return false;
             }
             // If it is not type intersection then we can skip that value after first successful check
-            if ($or) {
+            if ($or){
                 return true;
             }
         }
@@ -150,7 +150,7 @@ 
     {
         $name = $type->getName();
 
-        if ($type->isBuiltin()) {
+        if ($type->isBuiltin()){
             return match ($name) {
                 'mixed' => true,
                 'string' => \is_string($value),
@@ -183,13 +183,13 @@ 
 
         // Try to resolve parameter by name
         $res = $state->resolveParameterByNameOrPosition($parameter, $isVariadic);
-        if ($res !== [] || $isVariadic) {
+        if ($res !== [] || $isVariadic){
             // validate
-            if ($isVariadic) {
-                foreach ($res as $k => &$v) {
-                    $this->processArgument($state, $v, validateWith: $validate ? $parameter : null, key: $k);
+            if ($isVariadic){
+                foreach ($res as $k => &$v){
+                    $this->processArgument($state, $v, validateWith: $validate ? $parameter : null, key : $k);
                 }
-            } else {
+            }else{
                 $this->processArgument($state, $res[0], validateWith: $validate ? $parameter : null);
             }
 
@@ -197,39 +197,39 @@ 
         }
 
         $error = null;
-        if ($hasType) {
+        if ($hasType){
             /** @var ReflectionIntersectionType|ReflectionUnionType|ReflectionNamedType $reflectionType */
             $reflectionType = $parameter->getType();
 
-            if ($reflectionType instanceof ReflectionIntersectionType) {
+            if ($reflectionType instanceof ReflectionIntersectionType){
                 throw new UnsupportedTypeException($parameter->getDeclaringFunction(), $parameter->getName());
             }
 
             $types = $reflectionType instanceof ReflectionNamedType ? [$reflectionType] : $reflectionType->getTypes();
-            foreach ($types as $namedType) {
-                try {
-                    if ($this->resolveNamedType($state, $parameter, $namedType, $validate)) {
+            foreach ($types as $namedType){
+                try{
+                    if ($this->resolveNamedType($state, $parameter, $namedType, $validate)){
                         return true;
                     }
-                } catch (Throwable $e) {
+                }catch (Throwable $e){
                     $error = $e;
                 }
             }
         }
 
-        if ($parameter->isDefaultValueAvailable()) {
+        if ($parameter->isDefaultValueAvailable()){
             $argument = $parameter->getDefaultValue();
             $this->processArgument($state, $argument);
             return true;
         }
 
-        if ($hasType && $parameter->allowsNull()) {
+        if ($hasType && $parameter->allowsNull()){
             $argument = null;
             $this->processArgument($state, $argument);
             return true;
         }
 
-        if ($error === null) {
+        if ($error === null){
             return false;
         }
 
@@ -250,7 +250,7 @@ 
         ReflectionParameter $parameter,
         ReflectionNamedType $typeRef,
         bool $validate,
-    ) {
+    ){
         return !$typeRef->isBuiltin() && $this->resolveObjectParameter(
             $state,
             $typeRef->getName(),
@@ -293,15 +293,15 @@ 
         ResolvingState $state,
         mixed &$value,
         ReflectionParameter $validateWith = null,
-        int|string $key = null
+        int | string $key = null
     ): void {
         // Resolve Autowire objects
-        if ($value instanceof Autowire) {
+        if ($value instanceof Autowire){
             $value = $value->resolve($this->factory);
         }
 
         // Validation
-        if ($validateWith !== null && !$this->validateValueToParameter($validateWith, $value)) {
+        if ($validateWith !== null && !$this->validateValueToParameter($validateWith, $value)){
             throw new InvalidArgumentException(
                 $validateWith->getDeclaringFunction(),
                 $validateWith->getName()

src/Core/src/Config/Scalar.php

Spacing +2 added lines, -2 removed lines

@@ -7,8 +7,8 @@
 final class Scalar extends Binding
 {
     public function __construct(
-        public readonly bool|int|string|float $value,
-    ) {
+        public readonly bool | int | string | float $value,
+    ){
     }
 
     public function __toString(): string

src/Core/src/Config/Injectable.php

Spacing +2 added lines, -2 removed lines

@@ -17,8 +17,8 @@
      * @param string|InjectorInterface $injector Injector object or binding alias.
      */
     public function __construct(
-        public readonly string|InjectorInterface $injector,
-    ) {
+        public readonly string | InjectorInterface $injector,
+    ){
     }
 
     public function __toString(): string