spiral / framework

src/Core/src/Internal/Resolver.php

Braces +81 added lines, -38 removed lines

@@ -48,7 +48,8 @@ 
     ): array {
         $state = new ResolvingState($reflection, $parameters);
 
-        foreach ($reflection->getParameters() as $parameter) {
+        foreach ($reflection->getParameters() as $parameter)
+        {
             $this->resolveParameter($parameter, $state, $validate)
             or
             throw ArgumentResolvingException::createWithParam($reflection, $parameter->getName());
@@ -62,47 +63,59 @@ 
         $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 PositionalArgumentException::createWithParam($reflection, (string) $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 UnknownParameterException::createWithParam($reflection, (string) $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 MissingRequiredArgumentException::createWithParam($reflection, $name);
-            } else {
+            }
+            else
+            {
                 $value = &$arguments[$name];
                 unset($arguments[$name]);
             }
 
-            if (!$this->validateValueToParameter($parameter, $value)) {
+            if (!$this->validateValueToParameter($parameter, $value))
+            {
                 throw InvalidArgumentException::createWithParam($reflection, $name);
             }
         }
@@ -110,7 +123,8 @@ 
 
     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();
@@ -121,17 +135,21 @@ 
             $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;
             }
         }
@@ -146,7 +164,8 @@ 
     {
         $name = $type->getName();
 
-        if ($type->isBuiltin()) {
+        if ($type->isBuiltin())
+        {
             return match ($name) {
                 'mixed' => true,
                 'string' => \is_string($value),
@@ -179,13 +198,18 @@ 
 
         // Try to resolve parameter by name
         $res = $state->resolveParameterByNameOrPosition($param, $isVariadic);
-        if ($res !== [] || $isVariadic) {
+        if ($res !== [] || $isVariadic)
+        {
             // validate
-            if ($isVariadic) {
-                foreach ($res as $k => &$v) {
+            if ($isVariadic)
+            {
+                foreach ($res as $k => &$v)
+                {
                     $this->processArgument($state, $v, validateWith: $validate ? $param : null, key: $k);
                 }
-            } else {
+            }
+            else
+            {
                 $this->processArgument($state, $res[0], validateWith: $validate ? $param : null);
             }
 
@@ -193,18 +217,22 @@ 
         }
 
         $error = null;
-        while ($hasType) {
+        while ($hasType)
+        {
             /** @var \ReflectionIntersectionType|\ReflectionUnionType|\ReflectionNamedType $refType */
             $refType = $param->getType();
 
-            if ($refType::class === \ReflectionNamedType::class) {
-                if ($refType->isBuiltin()) {
+            if ($refType::class === \ReflectionNamedType::class)
+            {
+                if ($refType->isBuiltin())
+                {
                     break;
                 }
 
                 if (\interface_exists($refType->getName()) && !empty(
                     $attrs = $param->getAttributes(ProxyAttribute::class)
-                )) {
+                ))
+                {
                     $proxy = Proxy::create(
                         new \ReflectionClass($refType->getName()),
                         $param,
@@ -214,23 +242,33 @@ 
                     return true;
                 }
 
-                try {
-                    if ($this->resolveObject($state, $refType, $param, $validate)) {
+                try
+                {
+                    if ($this->resolveObject($state, $refType, $param, $validate))
+                    {
                         return true;
                     }
-                } catch (\Throwable $e) {
+                }
+                catch (\Throwable $e)
+                {
                     $error = $e;
                 }
                 break;
             }
 
-            if ($refType::class === \ReflectionUnionType::class) {
-                foreach ($refType->getTypes() as $namedType) {
-                    try {
-                        if (!$namedType->isBuiltin() && $this->resolveObject($state, $namedType, $param, $validate)) {
+            if ($refType::class === \ReflectionUnionType::class)
+            {
+                foreach ($refType->getTypes() as $namedType)
+                {
+                    try
+                    {
+                        if (!$namedType->isBuiltin() && $this->resolveObject($state, $namedType, $param, $validate))
+                        {
                             return true;
                         }
-                    } catch (\Throwable $e) {
+                    }
+                    catch (\Throwable $e)
+                    {
                         $error = $e;
                     }
                 }
@@ -240,19 +278,22 @@ 
             throw new UnsupportedTypeException($param->getDeclaringFunction(), $param->getName());
         }
 
-        if ($param->isDefaultValueAvailable()) {
+        if ($param->isDefaultValueAvailable())
+        {
             $argument = $param->getDefaultValue();
             $this->processArgument($state, $argument);
             return true;
         }
 
-        if ($hasType && $param->allowsNull()) {
+        if ($hasType && $param->allowsNull())
+        {
             $argument = null;
             $this->processArgument($state, $argument);
             return true;
         }
 
-        if ($error === null) {
+        if ($error === null)
+        {
             return false;
         }
 
@@ -293,12 +334,14 @@ 
         int|string|null $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 InvalidArgumentException::createWithParam(
                 $validateWith->getDeclaringFunction(),
                 $validateWith->getName(),

src/Core/src/Internal/Actor.php

Braces +149 added lines, -64 removed lines

@@ -96,20 +96,25 @@ 
         // Aliases to prevent circular dependencies
         $as = [];
         $actor = $this;
-        do {
+        do
+        {
             $bindings = &$actor->state->bindings;
             $singletons = &$actor->state->singletons;
             $injectors = &$actor->state->injectors;
             $binding = $bindings[$alias] ?? null;
-            if (\array_key_exists($alias, $singletons)) {
+            if (\array_key_exists($alias, $singletons))
+            {
                 $singleton = $singletons[$alias];
                 $injector = $injectors[$alias] ?? null;
                 return \is_object($singleton::class) ? $singleton::class : null;
             }
 
-            if ($binding !== null) {
-                if ($followAlias && $binding::class === Alias::class) {
-                    if ($binding->alias === $alias) {
+            if ($binding !== null)
+            {
+                if ($followAlias && $binding::class === Alias::class)
+                {
+                    if ($binding->alias === $alias)
+                    {
                         break;
                     }
 
@@ -124,7 +129,8 @@ 
                 return $binding->getReturnClass();
             }
 
-            if (\array_key_exists($alias, $injectors)) {
+            if (\array_key_exists($alias, $injectors))
+            {
                 $injector = $injectors[$alias];
                 $binding = $bindings[$alias] ?? null;
                 return $alias;
@@ -132,7 +138,8 @@ 
 
             // Go to parent scope
             $parent = $actor->scope->getParentActor();
-            if ($parent === null) {
+            if ($parent === null)
+            {
                 break;
             }
 
@@ -202,18 +209,23 @@ 
     private function resolveInjector(Config\Injectable $binding, Ctx $ctx, array $arguments, Tracer $tracer)
     {
         $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'.",
@@ -240,7 +252,8 @@ 
                 default => (string) $context,
             });
 
-            if (!$reflection->isInstance($instance)) {
+            if (!$reflection->isInstance($instance))
+            {
                 throw new InjectionException(
                     \sprintf(
                         "Invalid injection response for '%s'.",
@@ -250,12 +263,16 @@ 
             }
 
             return $instance;
-        } catch (TracedContainerException $e) {
+        }
+        catch (TracedContainerException $e)
+        {
             throw isset($injectorInstance) ? $e : $e::createWithTrace(\sprintf(
                 'Can\'t resolve `%s`.',
                 $tracer->getRootAlias(),
             ), $tracer->getTraces(), $e);
-        } finally {
+        }
+        finally
+        {
             $this->state->bindings[$ctx->class] ??= $binding;
         }
     }
@@ -267,18 +284,24 @@ 
         array $arguments,
         Tracer $tracer,
     ): mixed {
-        if ($binding->alias === $alias) {
+        if ($binding->alias === $alias)
+        {
             $instance = $this->autowire(
                 new Ctx(alias: $alias, class: $binding->alias, context: $context, singleton: $binding->singleton && $arguments === []),
                 $arguments,
                 $this,
                 $tracer,
             );
-        } else {
-            try {
+        }
+        else
+        {
+            try
+            {
                 //Binding is pointing to something else
                 $instance = $this->factory->make($binding->alias, $arguments, $context);
-            } catch (TracedContainerException $e) {
+            }
+            catch (TracedContainerException $e)
+            {
                 throw $e::createWithTrace(
                     $alias === $tracer->getRootAlias()
                         ? "Can't resolve `{$alias}`."
@@ -297,7 +320,8 @@ 
 
     private function resolveProxy(Config\Proxy $binding, string $alias, \Stringable|string|null $context): mixed
     {
-        if ($context instanceof RetryContext) {
+        if ($context instanceof RetryContext)
+        {
             return $binding->fallbackFactory === null
                 ? throw new RecursiveProxyException(
                     $alias,
@@ -308,7 +332,8 @@ 
 
         $result = Proxy::create(new \ReflectionClass($binding->getReturnClass()), $context, new Attribute\Proxy());
 
-        if ($binding->singleton) {
+        if ($binding->singleton)
+        {
             $this->state->singletons[$alias] = $result;
         }
 
@@ -322,7 +347,8 @@ 
         array $arguments,
         Tracer $tracer,
     ): object {
-        if ($arguments !== []) {
+        if ($arguments !== [])
+        {
             // Avoid singleton cache
             return $this->createInstance(
                 new Ctx(alias: $alias, class: $binding->value::class, context: $context, singleton: false),
@@ -332,7 +358,8 @@ 
             );
         }
 
-        if ($binding->singleton) {
+        if ($binding->singleton)
+        {
             $this->state->singletons[$alias] = $binding->value;
         }
 
@@ -349,9 +376,12 @@ 
         $target = $binding->autowire->alias;
         $ctx = new Ctx(alias: $alias, class: $target, context: $context, singleton: $binding->singleton && $arguments === [] ?: null);
 
-        if ($alias === $target) {
+        if ($alias === $target)
+        {
             $instance = $this->autowire($ctx, \array_merge($binding->autowire->parameters, $arguments), $this, $tracer);
-        } else {
+        }
+        else
+        {
             $instance = $binding->autowire->resolve($this->factory, $arguments);
             $this->validateConstraint($instance, $ctx);
         }
@@ -367,25 +397,34 @@ 
         Tracer $tracer,
     ): mixed {
         $ctx = new Ctx(alias: $alias, class: $alias, context: $context, singleton: $binding->singleton && $arguments === [] ?: null);
-        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 TracedContainerException::createWithTrace(
                 \sprintf('Invalid callable binding for `%s`.', $ctx->alias),
                 $tracer->getTraces(),
                 $e,
             );
-        } catch (TracedContainerException $e) {
+        }
+        catch (TracedContainerException $e)
+        {
             throw $e::createWithTrace(
                 \sprintf("Can't resolve `%s`: factory invocation failed.", $tracer->getRootAlias()),
                 $tracer->getTraces(),
                 $e,
             );
-        } catch (ContainerExceptionInterface $e) {
+        }
+        catch (ContainerExceptionInterface $e)
+        {
             throw $e;
-        } catch (\Throwable $e) {
+        }
+        catch (\Throwable $e)
+        {
             throw NotFoundException::createWithTrace(
                 \sprintf("Can't resolve `%s` due to factory invocation error: %s", $tracer->getRootAlias(), $e->getMessage()),
                 $tracer->getTraces(),
@@ -393,7 +432,8 @@ 
             );
         }
 
-        if (\is_object($instance)) {
+        if (\is_object($instance))
+        {
             $this->validateConstraint($instance, $ctx);
             return $this->registerInstance($ctx, $instance);
         }
@@ -410,8 +450,10 @@ 
     ): ?object {
         $avoidCache = $arguments !== [];
 
-        if (($avoidCache || $binding->reference->get() === null) && \class_exists($alias)) {
-            try {
+        if (($avoidCache || $binding->reference->get() === null) && \class_exists($alias))
+        {
+            try
+            {
                 $tracer->push(false, alias: $alias, source: \WeakReference::class, context: $context);
 
                 $object = $this->createInstance(
@@ -420,17 +462,22 @@ 
                     $this,
                     $tracer,
                 );
-                if ($avoidCache) {
+                if ($avoidCache)
+                {
                     return $object;
                 }
                 $binding->reference = \WeakReference::create($object);
-            } catch (\Throwable) {
+            }
+            catch (\Throwable)
+            {
                 throw TracedContainerException::createWithTrace(\sprintf(
                     'Can\'t resolve `%s`: can\'t instantiate `%s` from WeakReference binding.',
                     $tracer->getRootAlias(),
                     $alias,
                 ), $tracer->getTraces());
-            } finally {
+            }
+            finally
+            {
                 $tracer->pop();
             }
         }
@@ -446,13 +493,16 @@ 
         object $instance,
         Ctx $ctx,
     ): void {
-        if ($this->options->checkScope) {
+        if ($this->options->checkScope)
+        {
             // Check scope name
             $ctx->reflection ??= new \ReflectionClass($instance);
             $scopeName = ($ctx->reflection->getAttributes(Attribute\Scope::class)[0] ?? null)?->newInstance()->name;
-            if ($scopeName !== null) {
+            if ($scopeName !== null)
+            {
                 $scope = $this->scope;
-                while ($scope->getScopeName() !== $scopeName) {
+                while ($scope->getScopeName() !== $scopeName)
+                {
                     $scope = $scope->getParentScope() ?? throw new BadScopeException($scopeName, $instance::class);
                 }
             }
@@ -479,26 +529,34 @@ 
         Tracer $tracer,
     ): 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 attribute
         $actor = $fallbackActor ?? $this;
-        if ($this->options->checkScope) { # todo
+        if ($this->options->checkScope)
+        {
+# todo
             $ar = ($reflection->getAttributes(Attribute\Scope::class)[0] ?? null);
-            if ($ar !== null) {
+            if ($ar !== null)
+            {
                 /** @var Attribute\Scope $attr */
                 $attr = $ar->newInstance();
                 $scope = $this->scope;
                 $actor = $this;
                 // Go through all parent scopes
                 $needed = $actor;
-                while ($attr->name !== $scope->getScopeName()) {
+                while ($attr->name !== $scope->getScopeName())
+                {
                     $needed = $scope->getParentActor();
-                    if ($needed === null) {
+                    if ($needed === null)
+                    {
                         throw new BadScopeException($attr->name, $class);
                     }
 
@@ -511,11 +569,13 @@ 
         } # todo
 
         // We have to construct class using external injector when we know the exact context
-        if ($arguments === [] && $actor->binder->hasInjector($class)) {
+        if ($arguments === [] && $actor->binder->hasInjector($class))
+        {
             return $actor->resolveInjector($actor->state->bindings[$ctx->class], $ctx, $arguments, $tracer);
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable())
+        {
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -529,8 +589,10 @@ 
 
         $constructor = $reflection->getConstructor();
 
-        if ($constructor !== null) {
-            try {
+        if ($constructor !== null)
+        {
+            try
+            {
                 $newScope = $this !== $actor;
                 $debug = [
                     'action' => 'resolve arguments',
@@ -544,35 +606,48 @@ 
                 $tracer->push($newScope, ...$debug);
                 $tracer->push(true);
                 $args = $actor->resolver->resolveArguments($constructor, $arguments, $actor->options->validateArguments);
-            } catch (\Throwable $e) {
+            }
+            catch (\Throwable $e)
+            {
                 throw TracedContainerException::createWithTrace(
                     \sprintf(
                         "Can't resolve `%s`.",
                         $tracer->getRootAlias(),
                     ), $tracer->getTraces(), $e
                 );
-            } finally {
+            }
+            finally
+            {
                 $tracer->pop($newScope);
                 $tracer->pop(false);
             }
-            try {
+            try
+            {
                 // Using constructor with resolved arguments
                 $tracer->push(false, call: "$class::__construct", arguments: $args);
                 $tracer->push(true);
                 $instance = new $class(...$args);
-            } catch (\TypeError $e) {
+            }
+            catch (\TypeError $e)
+            {
                 throw new WrongTypeException($constructor, $e);
-            } catch (TracedContainerException $e) {
+            }
+            catch (TracedContainerException $e)
+            {
                 throw $e::createWithTrace(\sprintf(
                     'Can\'t resolve `%s`: failed constructing `%s`.',
                     $tracer->getRootAlias(),
                     $class,
                 ), $tracer->getTraces(), $e);
-            } finally {
+            }
+            finally
+            {
                 $tracer->pop(true);
                 $tracer->pop(false);
             }
-        } else {
+        }
+        else
+        {
             // No constructor specified
             $instance = $reflection->newInstance();
         }
@@ -604,12 +679,14 @@ 
      */
     private function isSingleton(Ctx $ctx): bool
     {
-        if (is_bool($ctx->singleton)) {
+        if (is_bool($ctx->singleton))
+        {
             return $ctx->singleton;
         }
 
         /** @psalm-suppress RedundantCondition https://github.com/vimeo/psalm/issues/9489 */
-        if ($ctx->reflection->implementsInterface(SingletonInterface::class)) {
+        if ($ctx->reflection->implementsInterface(SingletonInterface::class))
+        {
             return true;
         }
 
@@ -623,7 +700,8 @@ 
          * @var Attribute\Finalize|null $attribute
          */
         $attribute = ($ctx->reflection->getAttributes(Attribute\Finalize::class)[0] ?? null)?->newInstance();
-        if ($attribute === null) {
+        if ($attribute === null)
+        {
             return null;
         }
 
@@ -637,10 +715,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);
@@ -656,9 +738,12 @@ 
 
     private function validateArguments(ContextFunction $reflection, array $arguments = []): bool
     {
-        try {
+        try
+        {
             $this->resolver->validateArguments($reflection, $arguments);
-        } catch (\Throwable) {
+        }
+        catch (\Throwable)
+        {
             return false;
         }
 

src/Core/src/Exception/Container/TracedContainerException.php

Braces +4 added lines, -2 removed lines

@@ -30,9 +30,11 @@
     ): static {
         $class = static::class;
         // Merge traces
-        if ($previous instanceof self) {
+        if ($previous instanceof self)
+        {
             $merge = $previous->containerTrace;
-            if ($trace !== [] && $merge !== []) {
+            if ($trace !== [] && $merge !== [])
+            {
                 // merge lat element of $traces with first element of $merge
                 \array_push($trace[\count($trace) - 1], ...$merge[0]);
                 unset($merge[0]);

src/Core/src/Exception/Resolver/ResolvingException.php

Braces +3 added lines, -1 removed lines

@@ -6,4 +6,6 @@
 
 use Spiral\Core\Exception\Container\TracedContainerException;
 
-class ResolvingException extends TracedContainerException {}
+class ResolvingException extends TracedContainerException
+{
+}