spiral / framework

src/Core/tests/InjectableTest.php

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

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

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/Config/StateBinder.php

Braces +33 added lines, -15 removed lines

@@ -39,14 +39,18 @@ 
      */
     public function bind(string $alias, mixed $resolver): void
     {
-        if ($resolver instanceof Inflector && (\interface_exists($alias) || \class_exists($alias))) {
+        if ($resolver instanceof Inflector && (\interface_exists($alias) || \class_exists($alias)))
+        {
             $this->state->inflectors[$alias][] = $resolver;
             return;
         }
 
-        try {
+        try
+        {
             $config = $this->makeConfig($resolver, false);
-        } catch (\Throwable $e) {
+        }
+        catch (\Throwable $e)
+        {
             throw $this->invalidBindingException($alias, $resolver, $e);
         }
 
@@ -58,9 +62,12 @@ 
      */
     public function bindSingleton(string $alias, mixed $resolver): void
     {
-        try {
+        try
+        {
             $config = $this->makeConfig($resolver, true);
-        } catch (\Throwable $e) {
+        }
+        catch (\Throwable $e)
+        {
             throw $this->invalidBindingException($alias, $resolver, $e);
         }
 
@@ -72,9 +79,11 @@ 
         $bindings = &$this->state->bindings;
 
         $flags = [];
-        while ($binding = $bindings[$alias] ?? null and $binding::class === Alias::class) {
+        while ($binding = $bindings[$alias] ?? null and $binding::class === Alias::class)
+        {
             //Checking alias tree
-            if ($flags[$binding->alias] ?? false) {
+            if ($flags[$binding->alias] ?? false)
+            {
                 return $binding->alias === $alias ?: throw new Exception('Circular alias detected');
             }
 
@@ -99,7 +108,8 @@ 
     public function removeInjector(string $class): void
     {
         unset($this->state->injectors[$class]);
-        if (!isset($this->state->bindings[$class]) || $this->state->bindings[$class]::class !== Injectable::class) {
+        if (!isset($this->state->bindings[$class]) || $this->state->bindings[$class]::class !== Injectable::class)
+        {
             return;
         }
         unset($this->state->bindings[$class]);
@@ -107,13 +117,17 @@ 
 
     public function hasInjector(string $class): bool
     {
-        try {
+        try
+        {
             $reflection = new \ReflectionClass($class);
-        } catch (\ReflectionException $e) {
+        }
+        catch (\ReflectionException $e)
+        {
             throw new ContainerException($e->getMessage(), $e->getCode(), $e);
         }
 
-        if (\array_key_exists($class, $this->state->injectors)) {
+        if (\array_key_exists($class, $this->state->injectors))
+        {
             return true;
         }
 
@@ -128,7 +142,8 @@ 
         }
 
         // check interfaces
-        foreach ($this->state->injectors as $target => $injector) {
+        foreach ($this->state->injectors as $target => $injector)
+        {
             if (
                 (\class_exists($target, true) && $reflection->isSubclassOf($target))
                 ||
@@ -160,15 +175,18 @@ 
 
     private function makeConfigFromArray(array $resolver, bool $singleton): Binding
     {
-        if (\is_callable($resolver)) {
+        if (\is_callable($resolver))
+        {
             return new Factory($resolver, $singleton);
         }
 
         // Validate lazy invokable array
-        if (!isset($resolver[0]) || !isset($resolver[1]) || !\is_string($resolver[1]) || $resolver[1] === '') {
+        if (!isset($resolver[0]) || !isset($resolver[1]) || !\is_string($resolver[1]) || $resolver[1] === '')
+        {
             throw new InvalidArgumentException('Incompatible array declaration for resolver.');
         }
-        if ((!\is_string($resolver[0]) && !\is_object($resolver[0])) || $resolver[0] === '') {
+        if ((!\is_string($resolver[0]) && !\is_object($resolver[0])) || $resolver[0] === '')
+        {
             throw new InvalidArgumentException('Incompatible array declaration for resolver.');
         }
 

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);

src/Core/src/Container.php

Braces +49 added lines, -22 removed lines

@@ -168,16 +168,21 @@ 
         $binds = &$this->state->bindings;
         $singletons = &$this->state->singletons;
         $cleanup = $previous = $prevSin = [];
-        foreach ($bindings as $alias => $resolver) {
+        foreach ($bindings as $alias => $resolver)
+        {
             // Store previous bindings
-            if (isset($binds[$alias])) {
+            if (isset($binds[$alias]))
+            {
                 $previous[$alias] = $binds[$alias];
-            } else {
+            }
+            else
+            {
                 // Store bindings to be removed
                 $cleanup[] = $alias;
             }
             // Store previous singletons
-            if (isset($singletons[$alias])) {
+            if (isset($singletons[$alias]))
+            {
                 $prevSin[$alias] = $singletons[$alias];
                 unset($singletons[$alias]);
             }
@@ -185,21 +190,27 @@ 
             $this->binder->bind($alias, $resolver);
         }
 
-        try {
+        try
+        {
             return ContainerScope::getContainer() !== $this
                 ? ContainerScope::runScope($this, $scope)
                 : $scope($this);
-        } finally {
+        }
+        finally
+        {
             // Remove new bindings
-            foreach ($cleanup as $alias) {
+            foreach ($cleanup as $alias)
+            {
                 unset($binds[$alias], $singletons[$alias]);
             }
             // Restore previous bindings
-            foreach ($previous as $alias => $resolver) {
+            foreach ($previous as $alias => $resolver)
+            {
                 $binds[$alias] = $resolver;
             }
             // Restore singletons
-            foreach ($prevSin as $alias => $instance) {
+            foreach ($prevSin as $alias => $instance)
+            {
                 $singletons[$alias] = $instance;
             }
         }
@@ -213,32 +224,40 @@ 
         // Open scope
         $container = new self($this->config, $name);
 
-        try {
+        try
+        {
             // Configure scope
             $container->scope->setParent($this, $this->scope);
 
             // Add specific bindings
-            foreach ($bindings as $alias => $resolver) {
+            foreach ($bindings as $alias => $resolver)
+            {
                 $container->binder->bind($alias, $resolver);
             }
 
             return ContainerScope::runScope(
                 $container,
                 static function (self $container) use ($autowire, $closure): mixed {
-                    try {
+                    try
+                    {
                         return $autowire
                             ? $container->invoke($closure)
                             : $closure($container);
-                    } finally {
+                    }
+                    finally
+                    {
                         $container->closeScope();
                     }
                 }
             );
-        } finally {
+        }
+        finally
+        {
             // Check the container has not been leaked
             $link = \WeakReference::create($container);
             unset($container);
-            if ($link->get() !== null) {
+            if ($link->get() !== null)
+            {
                 throw new ScopeContainerLeakedException($name, $this->scope->getParentScopeNames());
             }
         }
@@ -340,8 +359,10 @@ 
         ]);
 
         // Create container services
-        foreach ($container->config as $property => $class) {
-            if (\property_exists($container, $property)) {
+        foreach ($container->config as $property => $class)
+        {
+            if (\property_exists($container, $property))
+            {
                 $container->$property = $constructor->get($property, $class);
             }
         }
@@ -355,7 +376,8 @@ 
     private function closeScope(): void
     {
         /** @psalm-suppress RedundantPropertyInitializationCheck */
-        if (!isset($this->scope)) {
+        if (!isset($this->scope))
+        {
             $this->destruct();
             return;
         }
@@ -364,10 +386,14 @@ 
 
         // Run finalizers
         $errors = [];
-        foreach ($this->state->finalizers as $finalizer) {
-            try {
+        foreach ($this->state->finalizers as $finalizer)
+        {
+            try
+            {
                 $this->invoker->invoke($finalizer);
-            } catch (\Throwable $e) {
+            }
+            catch (\Throwable $e)
+            {
                 $errors[] = $e;
             }
         }
@@ -376,7 +402,8 @@ 
         $this->destruct();
 
         // Throw collected errors
-        if ($errors !== []) {
+        if ($errors !== [])
+        {
             throw new FinalizersException($scopeName, $errors);
         }
     }