spiral / framework

src/Core/src/Internal/Factory.php

Spacing +39 added lines, -39 removed lines

@@ -54,19 +54,19 @@ 
      */
     public function make(string $alias, array $parameters = [], string $context = null): mixed
     {
-        if (!isset($this->state->bindings[$alias])) {
+        if (!isset($this->state->bindings[$alias])){
             $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($alias, $parameters, $context);
-            } finally {
+            }finally{
                 $this->tracer->pop(false);
             }
         }
 
         $avoidCache = $parameters !== [];
         $binding = $this->state->bindings[$alias];
-        try {
+        try{
             $this->tracer->push(
                 false,
                 action: 'resolve from binding',
@@ -76,23 +76,23 @@ 
             );
             $this->tracer->push(true);
 
-            if (\is_object($binding)) {
-                if ($binding::class === WeakReference::class) {
-                    if (($avoidCache || $binding->get() === null) && \class_exists($alias)) {
-                        try {
+            if (\is_object($binding)){
+                if ($binding::class === WeakReference::class){
+                    if (($avoidCache || $binding->get() === null) && \class_exists($alias)){
+                        try{
                             $this->tracer->push(false, alias: $alias, source: WeakReference::class, context: $context);
                             $object = $this->createInstance($alias, $parameters, $context);
-                            if ($avoidCache) {
+                            if ($avoidCache){
                                 return $object;
                             }
                             $binding = $this->state->bindings[$alias] = WeakReference::create($object);
-                        } catch (\Throwable) {
+                        }catch (\Throwable){
                             throw new ContainerException($this->tracer->combineTraceMessage(\sprintf(
                                 'Can\'t resolve `%s`: can\'t instantiate `%s` from WeakReference binding.',
                                 $this->tracer->getRootAlias(),
                                 $alias,
                             )));
-                        } finally {
+                        }finally{
                             $this->tracer->pop();
                         }
                     }
@@ -104,7 +104,7 @@ 
                     : $binding;
             }
 
-            if (\is_string($binding)) {
+            if (\is_string($binding)){
                 return $binding === $alias
                     ? $this->autowire($alias, $parameters, $context)
                     //Binding is pointing to something else
@@ -112,20 +112,20 @@ 
             }
 
             unset($this->state->bindings[$alias]);
-            try {
+            try{
                 $instance = $binding[0] === $alias
                     ? $this->autowire($alias, $parameters, $context)
                     : $this->evaluateBinding($alias, $binding[0], $parameters, $context);
-            } finally {
+            }finally{
                 /** @psalm-var class-string $alias */
                 $this->state->bindings[$alias] = $binding;
             }
-        } finally {
+        }finally{
             $this->tracer->pop(true);
             $this->tracer->pop(false);
         }
 
-        if ($binding[1]) {
+        if ($binding[1]){
             // Indicates singleton
             /** @psalm-var class-string $alias */
             $this->state->bindings[$alias] = $instance;
@@ -150,7 +150,7 @@ 
                 &&
                 (isset($this->state->injectors[$class]) || $this->binder->hasInjector($class))
         ))
-        ) {
+        ){
             throw new NotFoundException($this->tracer->combineTraceMessage(\sprintf(
                 'Can\'t resolve `%s`: undefined class or binding `%s`.',
                 $this->tracer->getRootAlias(),
@@ -179,18 +179,18 @@ 
         array $parameters,
         string $context = null
     ): mixed {
-        if (\is_string($target)) {
+        if (\is_string($target)){
             // Reference
             return $this->make($target, $parameters, $context);
         }
 
-        if ($target instanceof Autowire) {
+        if ($target instanceof Autowire){
             return $target->resolve($this, $parameters);
         }
 
-        try {
+        try{
             return $this->invoker->invoke($target, $parameters);
-        } catch (NotCallableException $e) {
+        }catch (NotCallableException $e){
             throw new ContainerException(
                 $this->tracer->combineTraceMessage(\sprintf('Invalid binding for `%s`.', $alias)),
                 $e->getCode(),
@@ -214,20 +214,20 @@ 
      */
     private function createInstance(string $class, array $parameters, string $context = null): object
     {
-        try {
+        try{
             $reflection = new \ReflectionClass($class);
-        } catch (\ReflectionException $e) {
+        }catch (\ReflectionException $e){
             throw new ContainerException($e->getMessage(), $e->getCode(), $e);
         }
 
         //We have to construct class using external injector when we know exact context
-        if ($parameters === [] && $this->binder->hasInjector($class)) {
+        if ($parameters === [] && $this->binder->hasInjector($class)){
             $injector = $this->state->injectors[$reflection->getName()];
 
-            try {
+            try{
                 $injectorInstance = $this->container->get($injector);
 
-                if (!$injectorInstance instanceof InjectorInterface) {
+                if (!$injectorInstance instanceof InjectorInterface){
                     throw new InjectionException(
                         \sprintf(
                             "Class '%s' must be an instance of InjectorInterface for '%s'.",
@@ -242,7 +242,7 @@ 
                  * @psalm-suppress RedundantCondition
                  */
                 $instance = $injectorInstance->createInjection($reflection, $context);
-                if (!$reflection->isInstance($instance)) {
+                if (!$reflection->isInstance($instance)){
                     throw new InjectionException(
                         \sprintf(
                             "Invalid injection response for '%s'.",
@@ -252,12 +252,12 @@ 
                 }
 
                 return $instance;
-            } finally {
+            }finally{
                 $this->state->injectors[$reflection->getName()] = $injector;
             }
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable()){
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -270,12 +270,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(
@@ -285,22 +285,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();
         }
@@ -321,9 +321,9 @@ 
     private function registerInstance(object $instance): object
     {
         //Declarative singletons
-        if ($instance instanceof SingletonInterface) {
+        if ($instance instanceof SingletonInterface){
             $alias = $instance::class;
-            if (!isset($this->state->bindings[$alias])) {
+            if (!isset($this->state->bindings[$alias])){
                 $this->state->bindings[$alias] = $instance;
             }
         }

Braces +89 added lines, -38 removed lines

@@ -54,19 +54,24 @@ 
      */
     public function make(string $alias, array $parameters = [], string $context = null): mixed
     {
-        if (!isset($this->state->bindings[$alias])) {
+        if (!isset($this->state->bindings[$alias]))
+        {
             $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($alias, $parameters, $context);
-            } finally {
+            }
+            finally
+            {
                 $this->tracer->pop(false);
             }
         }
 
         $avoidCache = $parameters !== [];
         $binding = $this->state->bindings[$alias];
-        try {
+        try
+        {
             $this->tracer->push(
                 false,
                 action: 'resolve from binding',
@@ -76,23 +81,32 @@ 
             );
             $this->tracer->push(true);
 
-            if (\is_object($binding)) {
-                if ($binding::class === WeakReference::class) {
-                    if (($avoidCache || $binding->get() === null) && \class_exists($alias)) {
-                        try {
+            if (\is_object($binding))
+            {
+                if ($binding::class === WeakReference::class)
+                {
+                    if (($avoidCache || $binding->get() === null) && \class_exists($alias))
+                    {
+                        try
+                        {
                             $this->tracer->push(false, alias: $alias, source: WeakReference::class, context: $context);
                             $object = $this->createInstance($alias, $parameters, $context);
-                            if ($avoidCache) {
+                            if ($avoidCache)
+                            {
                                 return $object;
                             }
                             $binding = $this->state->bindings[$alias] = WeakReference::create($object);
-                        } catch (\Throwable) {
+                        }
+                        catch (\Throwable)
+                        {
                             throw new ContainerException($this->tracer->combineTraceMessage(\sprintf(
                                 'Can\'t resolve `%s`: can\'t instantiate `%s` from WeakReference binding.',
                                 $this->tracer->getRootAlias(),
                                 $alias,
                             )));
-                        } finally {
+                        }
+                        finally
+                        {
                             $this->tracer->pop();
                         }
                     }
@@ -104,7 +118,8 @@ 
                     : $binding;
             }
 
-            if (\is_string($binding)) {
+            if (\is_string($binding))
+            {
                 return $binding === $alias
                     ? $this->autowire($alias, $parameters, $context)
                     //Binding is pointing to something else
@@ -112,20 +127,26 @@ 
             }
 
             unset($this->state->bindings[$alias]);
-            try {
+            try
+            {
                 $instance = $binding[0] === $alias
                     ? $this->autowire($alias, $parameters, $context)
                     : $this->evaluateBinding($alias, $binding[0], $parameters, $context);
-            } finally {
+            }
+            finally
+            {
                 /** @psalm-var class-string $alias */
                 $this->state->bindings[$alias] = $binding;
             }
-        } finally {
+        }
+        finally
+        {
             $this->tracer->pop(true);
             $this->tracer->pop(false);
         }
 
-        if ($binding[1]) {
+        if ($binding[1])
+        {
             // Indicates singleton
             /** @psalm-var class-string $alias */
             $this->state->bindings[$alias] = $instance;
@@ -179,18 +200,23 @@ 
         array $parameters,
         string $context = null
     ): mixed {
-        if (\is_string($target)) {
+        if (\is_string($target))
+        {
             // Reference
             return $this->make($target, $parameters, $context);
         }
 
-        if ($target instanceof Autowire) {
+        if ($target instanceof Autowire)
+        {
             return $target->resolve($this, $parameters);
         }
 
-        try {
+        try
+        {
             return $this->invoker->invoke($target, $parameters);
-        } catch (NotCallableException $e) {
+        }
+        catch (NotCallableException $e)
+        {
             throw new ContainerException(
                 $this->tracer->combineTraceMessage(\sprintf('Invalid binding for `%s`.', $alias)),
                 $e->getCode(),
@@ -214,20 +240,26 @@ 
      */
     private function createInstance(string $class, array $parameters, string $context = null): object
     {
-        try {
+        try
+        {
             $reflection = new \ReflectionClass($class);
-        } catch (\ReflectionException $e) {
+        }
+        catch (\ReflectionException $e)
+        {
             throw new ContainerException($e->getMessage(), $e->getCode(), $e);
         }
 
         //We have to construct class using external injector when we know exact context
-        if ($parameters === [] && $this->binder->hasInjector($class)) {
+        if ($parameters === [] && $this->binder->hasInjector($class))
+        {
             $injector = $this->state->injectors[$reflection->getName()];
 
-            try {
+            try
+            {
                 $injectorInstance = $this->container->get($injector);
 
-                if (!$injectorInstance instanceof InjectorInterface) {
+                if (!$injectorInstance instanceof InjectorInterface)
+                {
                     throw new InjectionException(
                         \sprintf(
                             "Class '%s' must be an instance of InjectorInterface for '%s'.",
@@ -242,7 +274,8 @@ 
                  * @psalm-suppress RedundantCondition
                  */
                 $instance = $injectorInstance->createInjection($reflection, $context);
-                if (!$reflection->isInstance($instance)) {
+                if (!$reflection->isInstance($instance))
+                {
                     throw new InjectionException(
                         \sprintf(
                             "Invalid injection response for '%s'.",
@@ -252,12 +285,15 @@ 
                 }
 
                 return $instance;
-            } finally {
+            }
+            finally
+            {
                 $this->state->injectors[$reflection->getName()] = $injector;
             }
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable())
+        {
             $itIs = match (true) {
                 $reflection->isEnum() => 'Enum',
                 $reflection->isAbstract() => 'Abstract class',
@@ -270,12 +306,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(
@@ -285,22 +325,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();
         }
@@ -321,9 +370,11 @@ 
     private function registerInstance(object $instance): object
     {
         //Declarative singletons
-        if ($instance instanceof SingletonInterface) {
+        if ($instance instanceof SingletonInterface)
+        {
             $alias = $instance::class;
-            if (!isset($this->state->bindings[$alias])) {
+            if (!isset($this->state->bindings[$alias]))
+            {
                 $this->state->bindings[$alias] = $instance;
             }
         }