spiral / framework

src/Core/tests/Internal/Proxy/ProxyTest.php

Braces +22 added lines, -11 removed lines

@@ -35,7 +35,8 @@ 
         $root->invoke(static function (
             #[Proxy] MockInterface $mock,
             #[Proxy(/*proxyOverloads: true*/)] EmptyInterface $empty,
-        ) use ($var) {
+        ) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             $proxy->bar(name: 'foo'); // Possible to run
@@ -52,7 +53,8 @@ 
 
         self::expectExceptionMessageMatches('/Call to undefined method/i');
 
-        $root->invoke(static function (#[Proxy] EmptyInterface $proxy) {
+        $root->invoke(static function (#[Proxy] EmptyInterface $proxy)
+        {
             $proxy->bar(name: 'foo'); // Possible to run
         });
     }
@@ -67,7 +69,8 @@ 
         $root->invoke(static function (
             #[Proxy] MockInterface $mock,
             #[Proxy(/*proxyOverloads: true*/)] EmptyInterface $empty,
-        ) use ($var) {
+        ) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             self::assertSame(['foo', 'bar', 'baz', 69], $proxy->extra('foo', 'bar', 'baz', 69));
@@ -87,7 +90,8 @@ 
         $root->invoke(static function (
             #[Proxy] MockInterface $mock,
             #[Proxy(/*proxyOverloads: true*/)] EmptyInterface $empty,
-        ) use ($var) {
+        ) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             self::assertSame(['foo', 'bar', 'baz', 69], $proxy->extraVariadic('foo', 'bar', 'baz', 69));
@@ -109,7 +113,8 @@ 
         $root->bindSingleton(MockInterface::class, Stub\MockInterfaceImpl::class);
         $root->bindSingleton(EmptyInterface::class, Stub\MockInterfaceImpl::class);
 
-        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var) {
+        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             $str = 'bar';
@@ -129,7 +134,8 @@ 
         $root->bindSingleton(MockInterface::class, Stub\MockInterfaceImpl::class);
         $root->bindSingleton(EmptyInterface::class, Stub\MockInterfaceImpl::class);
 
-        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var) {
+        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
 
@@ -152,7 +158,8 @@ 
         $root->bindSingleton(MockInterface::class, Stub\MockInterfaceImpl::class);
         $root->bindSingleton(EmptyInterface::class, Stub\MockInterfaceImpl::class);
 
-        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var) {
+        $root->invoke(static function (#[Proxy] MockInterface $mock, #[Proxy] EmptyInterface $empty) use ($var)
+        {
             /** @var MockInterfaceImpl $proxy */
             $proxy = $$var;
             $str1 = 'bar';
@@ -193,7 +200,8 @@ 
         $this->assertInstanceOf($interface, $proxy);
         $this->assertNotInstanceOf(MockInterfaceImpl::class, $proxy);
 
-        $root->runScope(new Scope('foo'), static function (Container $container) use ($interface, $proxy) {
+        $root->runScope(new Scope('foo'), static function (Container $container) use ($interface, $proxy)
+        {
             $proxy->bar(name: 'foo'); // Possible to run
             self::assertSame('foo', $proxy->baz('foo', 42));
             self::assertSame(123, $proxy->qux(age: 123));
@@ -243,7 +251,8 @@ 
         $proxy = $root->get($interface);
         $this->assertInstanceOf($interface, $proxy);
 
-        $root->runScope(new Scope('foo'), static function () use ($proxy) {
+        $root->runScope(new Scope('foo'), static function () use ($proxy)
+        {
             $proxy->bar(name: 'foo'); // Possible to run
             self::assertSame('foo', $proxy->baz('foo', 42));
             self::assertSame(123, $proxy->qux(age: 123));
@@ -271,7 +280,8 @@ 
         $proxy = $root->get($interface);
         $this->assertInstanceOf($interface, $proxy);
 
-        $root->runScope(new Scope('foo'), static function () use ($proxy) {
+        $root->runScope(new Scope('foo'), static function () use ($proxy)
+        {
             $proxy->bar(name: 'foo'); // Possible to run
             self::assertSame('foo', $proxy->baz('foo', 42));
             self::assertSame(123, $proxy->qux(age: 123));
@@ -293,7 +303,8 @@ 
         $root->getBinder('foo')->bindSingleton($interface, Stub\MockInterfaceImpl::class);
         $root->bindSingleton($interface, new Config\DeprecationProxy($interface, true, 'foo', '4.0'));
 
-        $root->runScope(new Scope('foo'), static function (Container $container) use ($interface) {
+        $root->runScope(new Scope('foo'), static function (Container $container) use ($interface)
+        {
             $proxy = $container->get($interface);
 
             $proxy->bar(name: 'foo'); // Possible to run

src/Core/src/Config/DeprecationProxy.php

Braces +2 added lines, -1 removed lines

@@ -16,7 +16,8 @@
         private readonly ?string $version = null,
         private readonly ?string $message = null,
     ) {
-        if (($scope === null || $version === null) && $message === null) {
+        if (($scope === null || $version === null) && $message === null)
+        {
             throw new \InvalidArgumentException('Scope and version or custom message must be provided.');
         }
 

src/Core/src/Config/Proxy.php

Braces +2 added lines, -1 removed lines

@@ -13,7 +13,8 @@
         protected readonly string $interface,
         public readonly bool $singleton = false,
     ) {
-        if (!\interface_exists($interface)) {
+        if (!\interface_exists($interface))
+        {
             throw new \InvalidArgumentException(\sprintf('Interface `%s` does not exist.', $interface));
         }
     }

src/Core/src/Internal/Factory.php

Braces +121 added lines, -52 removed lines

@@ -65,17 +65,20 @@ 
      */
     public function make(string $alias, array $parameters = [], Stringable|string|null $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',
@@ -105,7 +108,9 @@ 
                     ->resolveWeakReference($binding, $alias, $context, $parameters),
                 default => $binding,
             };
-        } finally {
+        }
+        finally
+        {
             $this->state->bindings[$alias] ??= $binding;
             $this->tracer->pop(true);
             $this->tracer->pop(false);
@@ -119,18 +124,23 @@ 
     private function resolveInjector(Config\Injectable $binding, Ctx $ctx, array $arguments)
     {
         $context = $ctx->context;
-        try {
+        try
+        {
             $reflection = $ctx->reflection ??= new \ReflectionClass($ctx->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'.",
@@ -157,7 +167,8 @@ 
                 default => (string)$context,
             });
 
-            if (!$reflection->isInstance($instance)) {
+            if (!$reflection->isInstance($instance))
+            {
                 throw new InjectionException(
                     \sprintf(
                         "Invalid injection response for '%s'.",
@@ -167,7 +178,9 @@ 
             }
 
             return $instance;
-        } finally {
+        }
+        finally
+        {
             $this->state->bindings[$ctx->class] ??= $binding;
         }
     }
@@ -186,7 +199,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;
         }
 
@@ -197,7 +211,8 @@ 
     {
         $result = Proxy::create(new \ReflectionClass($binding->getInterface()), $context, new Attribute\Proxy());
 
-        if ($binding->singleton) {
+        if ($binding->singleton)
+        {
             $this->state->singletons[$alias] = $result;
         }
 
@@ -238,11 +253,14 @@ 
         array $arguments,
     ): mixed {
         $ctx = new Ctx(alias: $alias, class: $alias, context: $context, singleton: $binding->singleton);
-        try {
+        try
+        {
             $instance = $binding::class === 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(),
@@ -261,19 +279,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, context: $context),
                     $arguments,
                 );
-                if ($avoidCache) {
+                if ($avoidCache)
+                {
                     return $object;
                 }
                 $binding->reference = WeakReference::create($object);
-            } catch (\Throwable) {
+            }
+            catch (\Throwable)
+            {
                 throw new ContainerException(
                     $this->tracer->combineTraceMessage(
                         \sprintf(
@@ -283,7 +306,9 @@ 
                         )
                     )
                 );
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop();
             }
         }
@@ -298,19 +323,26 @@ 
     ): mixed {
         $parent = $this->scope->getParentFactory();
 
-        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(),
                 ]);
                 /** @psalm-suppress TooManyArguments */
                 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,
@@ -319,19 +351,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, context: $context),
                 $parameters,
             );
-        } finally {
+        }
+        finally
+        {
             $this->tracer->pop(false);
         }
     }
@@ -381,7 +418,8 @@ 
         // Check scope name
         $ctx->reflection = new \ReflectionClass($instance);
         $scopeName = ($ctx->reflection->getAttributes(Attribute\Scope::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);
         }
 
@@ -408,24 +446,30 @@ 
         array $arguments,
     ): 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(Attribute\Scope::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 the exact context
-        if ($arguments === [] && $this->binder->hasInjector($class)) {
+        if ($arguments === [] && $this->binder->hasInjector($class))
+        {
             return $this->resolveInjector($this->state->bindings[$ctx->class], $ctx, $arguments);
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable())
+        {
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -438,12 +482,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);
                 $args = $this->resolver->resolveArguments($constructor, $arguments);
-            } catch (ValidationException $e) {
+            }
+            catch (ValidationException $e)
+            {
                 throw new ContainerException(
                     $this->tracer->combineTraceMessage(
                         \sprintf(
@@ -453,22 +501,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: $args);
                 $this->tracer->push(true);
                 $instance = new $class(...$args);
-            } 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();
         }
@@ -486,13 +543,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;
         }
 
@@ -504,12 +563,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;
         }
 
@@ -523,7 +584,8 @@ 
          * @var Attribute\Finalize|null $attribute
          */
         $attribute = ($ctx->reflection->getAttributes(Attribute\Finalize::class)[0] ?? null)?->newInstance();
-        if ($attribute === null) {
+        if ($attribute === null)
+        {
             return null;
         }
 
@@ -537,10 +599,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);
@@ -556,9 +622,12 @@ 
 
     private function validateArguments(ContextFunction $reflection, array $arguments = []): bool
     {
-        try {
+        try
+        {
             $this->resolver->validateArguments($reflection, $arguments);
-        } catch (\Throwable) {
+        }
+        catch (\Throwable)
+        {
             return false;
         }