spiral / framework

src/Boot/tests/BootloadManager/BootloadersTest.php

Braces +6 added lines, -3 removed lines

@@ -26,11 +26,13 @@ 
             SampleBootWithMethodBoot::class,
             SampleBoot::class,
         ], [
-            static function(Container $container, SampleBoot $boot) {
+            static function(Container $container, SampleBoot $boot)
+            {
                 $container->bind('efg', $boot);
             }
         ], [
-            static function(Container $container, SampleBoot $boot) {
+            static function(Container $container, SampleBoot $boot)
+            {
                 $container->bind('ghi', $boot);
             }
         ]);
@@ -81,7 +83,8 @@ 
         $bootloader = $this->getBootloadManager();
 
         $bootloader->bootload([
-            new class () extends Bootloader {
+            new class () extends Bootloader
+            {
                 public const BINDINGS = ['abc' => self::class];
                 public const SINGLETONS = ['single' => self::class];
 

src/Boot/src/BootloadManager/DefaultInvokerStrategy.php

Braces +10 added lines, -5 removed lines

@@ -26,13 +26,15 @@ 
         /** @psalm-suppress TooManyArguments */
         $bootloaders = \iterator_to_array($this->initializer->init($classes, $useRules));
 
-        foreach ($bootloaders as $data) {
+        foreach ($bootloaders as $data)
+        {
             $this->invokeBootloader($data['bootloader'], Methods::INIT, $data['options']);
         }
 
         $this->fireCallbacks($bootingCallbacks);
 
-        foreach ($bootloaders as $data) {
+        foreach ($bootloaders as $data)
+        {
             $this->invokeBootloader($data['bootloader'], Methods::BOOT, $data['options']);
         }
 
@@ -42,14 +44,16 @@ 
     private function invokeBootloader(BootloaderInterface $bootloader, Methods $method, array $options): void
     {
         $refl = new \ReflectionClass($bootloader);
-        if (!$refl->hasMethod($method->value)) {
+        if (!$refl->hasMethod($method->value))
+        {
             return;
         }
 
         $method = $refl->getMethod($method->value);
 
         $args = $this->resolver->resolveArguments($method);
-        if (!isset($args['boot'])) {
+        if (!isset($args['boot']))
+        {
             $args['boot'] = $options;
         }
 
@@ -61,7 +65,8 @@ 
      */
     private function fireCallbacks(array $callbacks): void
     {
-        foreach ($callbacks as $callback) {
+        foreach ($callbacks as $callback)
+        {
             $this->invoker->invoke($callback);
         }
     }

src/Boot/src/BootloadManager/Checker/RulesChecker.php

Braces +12 added lines, -6 removed lines

@@ -17,24 +17,30 @@
 
     public function canInitialize(BootloaderInterface|string $bootloader, ?BootloaderRules $rules = null): bool
     {
-        if ($rules === null) {
+        if ($rules === null)
+        {
             return true;
         }
 
-        if (!$rules->enabled) {
+        if (!$rules->enabled)
+        {
             return false;
         }
 
-        foreach ($rules->denyEnv as $env => $denyValues) {
+        foreach ($rules->denyEnv as $env => $denyValues)
+        {
             $value = $this->environment->get($env);
-            if ($value !== null && \in_array($value, (array) $denyValues, true)) {
+            if ($value !== null && \in_array($value, (array) $denyValues, true))
+            {
                 return false;
             }
         }
 
-        foreach ($rules->allowEnv as $env => $allowValues) {
+        foreach ($rules->allowEnv as $env => $allowValues)
+        {
             $value = $this->environment->get($env);
-            if ($value === null || !\in_array($value, (array) $allowValues, true)) {
+            if ($value === null || !\in_array($value, (array) $allowValues, true))
+            {
                 return false;
             }
         }

src/Boot/src/BootloadManager/Checker/ClassExistsChecker.php

Braces +4 added lines, -2 removed lines

@@ -15,11 +15,13 @@
      */
     public function canInitialize(BootloaderInterface|string $bootloader, ?BootloaderRules $rules = null): bool
     {
-        if (!\is_string($bootloader)) {
+        if (!\is_string($bootloader))
+        {
             return true;
         }
 
-        if (!\class_exists($bootloader)) {
+        if (!\class_exists($bootloader))
+        {
             throw new ClassNotFoundException(\sprintf('Bootloader class `%s` is not exist.', $bootloader));
         }
 

src/Boot/src/BootloadManager/Checker/BootloaderChecker.php

Braces +4 added lines, -2 removed lines

@@ -16,8 +16,10 @@
 
     public function canInitialize(BootloaderInterface|string $bootloader, ?BootloaderRules $rules = null): bool
     {
-        foreach ($this->registry->getCheckers() as $checker) {
-            if (!$checker->canInitialize($bootloader, $rules)) {
+        foreach ($this->registry->getCheckers() as $checker)
+        {
+            if (!$checker->canInitialize($bootloader, $rules))
+            {
                 return false;
             }
         }

src/Boot/src/BootloadManager/Initializer.php

Braces +28 added lines, -14 removed lines

@@ -45,21 +45,25 @@ 
     {
         $this->checker ??= $this->initDefaultChecker();
 
-        foreach ($classes as $bootloader => $options) {
+        foreach ($classes as $bootloader => $options)
+        {
             // default bootload syntax as simple array
-            if (\is_string($options) || $options instanceof BootloaderInterface) {
+            if (\is_string($options) || $options instanceof BootloaderInterface)
+            {
                 $bootloader = $options;
                 $options = [];
             }
             $options = $useRules ? $this->getBootloaderRules($bootloader, $options) : [];
 
-            if (!$this->checker->canInitialize($bootloader, $useRules ? $options : null)) {
+            if (!$this->checker->canInitialize($bootloader, $useRules ? $options : null))
+            {
                 continue;
             }
 
             $this->bootloaders->register($bootloader instanceof BootloaderInterface ? $bootloader::class : $bootloader);
 
-            if (!$bootloader instanceof BootloaderInterface) {
+            if (!$bootloader instanceof BootloaderInterface)
+            {
                 $bootloader = $this->container->get($bootloader);
             }
 
@@ -82,7 +86,8 @@ 
      */
     protected function initBootloader(BootloaderInterface $bootloader): iterable
     {
-        if ($bootloader instanceof DependedInterface) {
+        if ($bootloader instanceof DependedInterface)
+        {
             yield from $this->init($this->getDependencies($bootloader));
         }
 
@@ -100,11 +105,13 @@ 
      */
     protected function initBindings(array $bindings, array $singletons): void
     {
-        foreach ($bindings as $aliases => $resolver) {
+        foreach ($bindings as $aliases => $resolver)
+        {
             $this->binder->bind($aliases, $resolver);
         }
 
-        foreach ($singletons as $aliases => $resolver) {
+        foreach ($singletons as $aliases => $resolver)
+        {
             $this->binder->bindSingleton($aliases, $resolver);
         }
     }
@@ -117,8 +124,10 @@ 
 
         $methodsDeps = [];
 
-        foreach (Methods::cases() as $method) {
-            if ($reflectionClass->hasMethod($method->value)) {
+        foreach (Methods::cases() as $method)
+        {
+            if ($reflectionClass->hasMethod($method->value))
+            {
                 $methodsDeps[] = $this->findBootloaderClassesInMethod(
                     $reflectionClass->getMethod($method->value)
                 );
@@ -131,9 +140,11 @@ 
     protected function findBootloaderClassesInMethod(\ReflectionMethod $method): array
     {
         $args = [];
-        foreach ($method->getParameters() as $parameter) {
+        foreach ($method->getParameters() as $parameter)
+        {
             $type = $parameter->getType();
-            if ($type instanceof \ReflectionNamedType && $this->shouldBeBooted($type)) {
+            if ($type instanceof \ReflectionNamedType && $this->shouldBeBooted($type))
+            {
                 $args[] = $type->getName();
             }
         }
@@ -178,7 +189,8 @@ 
         string|BootloaderInterface $bootloader,
         array|callable|BootloaderRules $rules
     ): BootloaderRules {
-        if ($rules instanceof \Closure) {
+        if ($rules instanceof \Closure)
+        {
             $rules = $this->container instanceof ResolverInterface
                 ? $rules(...$this->container->resolveArguments(new \ReflectionFunction($rules)))
                 : $rules();
@@ -212,12 +224,14 @@ 
     private function getBootloaderRulesAttribute(string|BootloaderInterface $bootloader): ?BootloaderRules
     {
         $attribute = null;
-        if ($bootloader instanceof BootloaderInterface || \class_exists($bootloader)) {
+        if ($bootloader instanceof BootloaderInterface || \class_exists($bootloader))
+        {
             $ref = new \ReflectionClass($bootloader);
             $attribute = $ref->getAttributes(BootloaderRules::class)[0] ?? null;
         }
 
-        if ($attribute === null) {
+        if ($attribute === null)
+        {
             return null;
         }