spiral / framework

src/Queue/src/QueueableDetector.php

Spacing +3 added lines, -3 removed lines

@@ -23,7 +23,7 @@ 
     {
         $reflection = new \ReflectionClass($object);
 
-        if ($reflection->implementsInterface(QueueableInterface::class)) {
+        if ($reflection->implementsInterface(QueueableInterface::class)){
             return true;
         }
 
@@ -38,11 +38,11 @@ 
         $reflection = new \ReflectionClass($object);
 
         $attribute = $this->reader->firstClassMetadata($reflection, Queueable::class);
-        if ($attribute !== null) {
+        if ($attribute !== null){
             return $attribute->queue;
         }
 
-        if (\is_object($object) && $reflection->hasMethod('getQueue')) {
+        if (\is_object($object) && $reflection->hasMethod('getQueue')){
             return $reflection->getMethod('getQueue')->invoke($object);
         }
 

src/Models/src/Reflection/ReflectionEntity.php

Spacing +14 added lines, -14 removed lines

@@ -70,7 +70,7 @@ 
 
     public function getSecured(): mixed
     {
-        if ($this->getProperty('secured', true) === '*') {
+        if ($this->getProperty('secured', true) === '*'){
             return $this->getProperty('secured', true);
         }
 
@@ -105,8 +105,8 @@ 
     public function declaredMethods(): array
     {
         $methods = [];
-        foreach ($this->getMethods() as $method) {
-            if ($method->getDeclaringClass()->getName() != $this->getName()) {
+        foreach ($this->getMethods() as $method){
+            if ($method->getDeclaringClass()->getName() != $this->getName()){
                 continue;
             }
 
@@ -136,15 +136,15 @@ 
             self::MUTATOR_ACCESSOR => [],
         ];
 
-        foreach ((array)$this->getProperty('getters', true) as $field => $filter) {
+        foreach ((array)$this->getProperty('getters', true) as $field => $filter){
             $mutators[self::MUTATOR_GETTER][$field] = $filter;
         }
 
-        foreach ((array)$this->getProperty('setters', true) as $field => $filter) {
+        foreach ((array)$this->getProperty('setters', true) as $field => $filter){
             $mutators[self::MUTATOR_SETTER][$field] = $filter;
         }
 
-        foreach ((array)$this->getProperty('accessors', true) as $field => $filter) {
+        foreach ((array)$this->getProperty('accessors', true) as $field => $filter){
             $mutators[self::MUTATOR_ACCESSOR][$field] = $filter;
         }
 
@@ -160,7 +160,7 @@ 
      */
     public function getProperty(string $property, bool $merge = false): mixed
     {
-        if (isset($this->propertyCache[$property])) {
+        if (isset($this->propertyCache[$property])){
             //Property merging and trait events are pretty slow
             return $this->propertyCache[$property];
         }
@@ -168,27 +168,27 @@ 
         $properties = $this->reflection->getDefaultProperties();
         $constants = $this->reflection->getConstants();
 
-        if (isset($properties[$property])) {
+        if (isset($properties[$property])){
             //Read from default value
             $value = $properties[$property];
-        } elseif (isset($constants[\strtoupper($property)])) {
+        } elseif (isset($constants[\strtoupper($property)])){
             //Read from a constant
             $value = $constants[\strtoupper($property)];
-        } else {
+        }else{
             return null;
         }
 
         //Merge with parent value requested
-        if ($merge && \is_array($value) && !empty($parent = $this->parentReflection())) {
+        if ($merge && \is_array($value) && !empty($parent = $this->parentReflection())){
             $parentValue = $parent->getProperty($property, $merge);
 
-            if (\is_array($parentValue)) {
+            if (\is_array($parentValue)){
                 //Class values prior to parent values
                 $value = \array_merge($parentValue, $value);
             }
         }
 
-        if (!$this->reflection->isSubclassOf(SchematicEntity::class)) {
+        if (!$this->reflection->isSubclassOf(SchematicEntity::class)){
             return $value;
         }
 
@@ -203,7 +203,7 @@ 
     {
         $parentClass = $this->reflection->getParentClass();
 
-        if (!empty($parentClass) && $parentClass->getName() != static::BASE_CLASS) {
+        if (!empty($parentClass) && $parentClass->getName() != static::BASE_CLASS){
             $parent = clone $this;
             $parent->reflection = $this->getParentClass();
 

src/Reactor/src/Aggregator.php

Spacing +10 added lines, -10 removed lines

@@ -20,7 +20,7 @@ 
     public function __construct(
         private array $allowed,
         private array $elements = []
-    ) {
+    ){
     }
 
     /**
@@ -49,8 +49,8 @@ 
      */
     public function has(string $name): bool
     {
-        foreach ($this->elements as $element) {
-            if ($element instanceof NamedInterface && $element->getName() === $name) {
+        foreach ($this->elements as $element){
+            if ($element instanceof NamedInterface && $element->getName() === $name){
                 return true;
             }
         }
@@ -68,14 +68,14 @@ 
         $reflector = new \ReflectionObject($element);
 
         $allowed = false;
-        foreach ($this->allowed as $class) {
-            if ($reflector->isSubclassOf($class) || $element::class === $class) {
+        foreach ($this->allowed as $class){
+            if ($reflector->isSubclassOf($class) || $element::class === $class){
                 $allowed = true;
                 break;
             }
         }
 
-        if (!$allowed) {
+        if (!$allowed){
             $type = $element::class;
             throw new ReactorException(\sprintf("Elements with type '%s' are not allowed", $type));
         }
@@ -101,8 +101,8 @@ 
      */
     public function remove(string $name): self
     {
-        foreach ($this->elements as $index => $element) {
-            if ($element instanceof NamedInterface && $element->getName() === $name) {
+        foreach ($this->elements as $index => $element){
+            if ($element instanceof NamedInterface && $element->getName() === $name){
                 unset($this->elements[$index]);
             }
         }
@@ -152,8 +152,8 @@ 
      */
     protected function find(string $name): AggregableInterface
     {
-        foreach ($this->elements as $element) {
-            if ($element instanceof NamedInterface && $element->getName() === $name) {
+        foreach ($this->elements as $element){
+            if ($element instanceof NamedInterface && $element->getName() === $name){
                 return $element;
             }
         }

src/Queue/src/Interceptor/Push/Core.php

Spacing +6 added lines, -6 removed lines

@@ -20,7 +20,7 @@ 
 {
     public function __construct(
         private readonly QueueInterface $connection,
-    ) {
+    ){
     }
 
     /**
@@ -31,14 +31,14 @@ 
         string $action,
         array $parameters = ['options' => null, 'payload' => []],
     ): string {
-        if ($parameters['options'] === null) {
+        if ($parameters['options'] === null){
             $parameters['options'] = new Options();
         }
 
         $tracer = $this->getTracer();
 
-        if (\method_exists($parameters['options'], 'withHeader')) {
-            foreach ($tracer->getContext() as $key => $data) {
+        if (\method_exists($parameters['options'], 'withHeader')){
+            foreach ($tracer->getContext() as $key => $data){
                 $parameters['options'] = $parameters['options']->withHeader($key, $data);
             }
         }
@@ -58,9 +58,9 @@ 
 
     private function getTracer(): TracerInterface
     {
-        try {
+        try{
             return ContainerScope::getContainer()->get(TracerInterface::class);
-        } catch (\Throwable $e) {
+        }catch (\Throwable $e){
             return new NullTracer();
         }
     }

src/Core/src/Internal/Factory.php

Spacing +57 added lines, -57 removed lines

@@ -66,17 +66,17 @@ 
      */
     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 +100,7 @@ 
                     ->resolveWeakReference($binding, $alias, $context, $parameters),
                 default => $binding,
             };
-        } finally {
+        }finally{
             $this->state->bindings[$alias] ??= $binding;
             $this->tracer->pop(true);
             $this->tracer->pop(false);
@@ -112,27 +112,27 @@ 
         string $alias,
         ?string $context,
         array $arguments,
-    ) {
-        $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context);
+    ){
+        $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'.",
@@ -146,7 +146,7 @@ 
              * @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'.",
@@ -156,7 +156,7 @@ 
             }
 
             return $instance;
-        } finally {
+        }finally{
             $this->state->bindings[$reflection->getName()] ??= $binding; //new Injector($injector);
         }
     }
@@ -169,13 +169,13 @@ 
     ): mixed {
         $result = $binding->alias === $alias
             ? $this->autowire(
-                new Ctx(alias: $alias, class: $binding->alias, parameter: $context, singleton: $binding->singleton),
+                new Ctx(alias : $alias, class : $binding->alias, parameter : $context, singleton : $binding->singleton),
                 $arguments,
             )
             //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;
         }
 
@@ -191,7 +191,7 @@ 
         $avoidCache = $arguments !== [];
         return $avoidCache
             ? $this->createInstance(
-                new Ctx(alias: $alias, class: $binding->value::class, parameter: $context),
+                new Ctx(alias : $alias, class : $binding->value::class, parameter : $context),
                 $arguments,
             )
             : $binding->value;
@@ -210,17 +210,17 @@ 
     }
 
     private function resolveFactory(
-        \Spiral\Core\Config\Factory|DeferredFactory $binding,
+        \Spiral\Core\Config\Factory | DeferredFactory $binding,
         string $alias,
         ?string $context,
         array $arguments,
     ): mixed {
-        $ctx = new Ctx(alias: $alias, class: $alias, parameter: $context, singleton: $binding->singleton);
-        try {
+        $ctx = new Ctx(alias : $alias, class : $alias, parameter : $context, singleton : $binding->singleton);
+        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(),
@@ -239,19 +239,19 @@ 
     ): ?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(
@@ -261,7 +261,7 @@ 
                         )
                     )
                 );
-            } finally {
+            }finally{
                 $this->tracer->pop();
             }
         }
@@ -273,18 +273,18 @@ 
     {
         $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,
@@ -293,19 +293,19 @@ 
                     '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);
         }
     }
@@ -327,7 +327,7 @@ 
                 &&
                 (isset($this->state->injectors[$ctx->class]) || $this->binder->hasInjector($ctx->class))
         ))
-        ) {
+        ){
             throw new NotFoundException($this->tracer->combineTraceMessage(\sprintf(
                 'Can\'t resolve `%s`: undefined class or binding `%s`.',
                 $this->tracer->getRootAlias(),
@@ -356,7 +356,7 @@ 
         // 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);
         }
 
@@ -383,24 +383,24 @@ 
         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',
@@ -413,12 +413,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(
@@ -428,22 +428,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();
         }
@@ -461,13 +461,13 @@ 
         $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;
         }
 
@@ -479,11 +479,11 @@ 
      */
     private function isSingleton(Ctx $ctx): bool
     {
-        if ($ctx->singleton === true) {
+        if ($ctx->singleton === true){
             return true;
         }
 
-        if ($ctx->reflection->implementsInterface(SingletonInterface::class)) {
+        if ($ctx->reflection->implementsInterface(SingletonInterface::class)){
             return true;
         }
 
@@ -497,7 +497,7 @@ 
          * @var Finalize|null $attribute
          */
         $attribute = ($ctx->reflection->getAttributes(Finalize::class)[0] ?? null)?->newInstance();
-        if ($attribute === null) {
+        if ($attribute === null){
             return null;
         }
 
@@ -511,10 +511,10 @@ 
     {
         $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

Spacing +30 added lines, -30 removed lines

@@ -49,11 +49,11 @@ 
     public const DEFAULT_ROOT_SCOPE_NAME = 'root';
 
     private Internal\State $state;
-    private ResolverInterface|Internal\Resolver $resolver;
-    private FactoryInterface|Internal\Factory $factory;
-    private ContainerInterface|Internal\Container $container;
-    private BinderInterface|Internal\Binder $binder;
-    private InvokerInterface|Internal\Invoker $invoker;
+    private ResolverInterface | Internal\Resolver $resolver;
+    private FactoryInterface | Internal\Factory $factory;
+    private ContainerInterface | Internal\Container $container;
+    private BinderInterface | Internal\Binder $binder;
+    private InvokerInterface | Internal\Invoker $invoker;
     private Internal\Scope $scope;
 
     /**
@@ -62,7 +62,7 @@ 
     public function __construct(
         private Config $config = new Config(),
         ?string $scopeName = self::DEFAULT_ROOT_SCOPE_NAME,
-    ) {
+    ){
         $this->initServices($this, $scopeName);
 
         /** @psalm-suppress RedundantPropertyInitializationCheck */
@@ -138,7 +138,7 @@ 
      * @throws ContainerException
      * @throws \Throwable
      */
-    public function get(string|Autowire $id, string $context = null): mixed
+    public function get(string | Autowire $id, string $context = null): mixed
     {
         /** @psalm-suppress TooManyArguments */
         return $this->container->get($id, $context);
@@ -166,16 +166,16 @@ 
         $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]);
             }
@@ -183,21 +183,21 @@ 
             $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;
             }
         }
@@ -211,32 +211,32 @@ 
         // 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());
             }
         }
@@ -268,7 +268,7 @@ 
      *
      * @psalm-param TResolver $resolver
      */
-    public function bindSingleton(string $alias, string|array|callable|object $resolver): void
+    public function bindSingleton(string $alias, string | array | callable | object $resolver): void
     {
         $this->binder->bindSingleton($alias, $resolver);
     }
@@ -335,8 +335,8 @@ 
         ]);
 
         // 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);
             }
         }
@@ -350,7 +350,7 @@ 
     private function closeScope(): void
     {
         /** @psalm-suppress RedundantPropertyInitializationCheck */
-        if (!isset($this->scope)) {
+        if (!isset($this->scope)){
             $this->destruct();
             return;
         }
@@ -359,10 +359,10 @@ 
 
         // 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;
             }
         }
@@ -371,7 +371,7 @@ 
         $this->destruct();
 
         // Throw collected errors
-        if ($errors !== []) {
+        if ($errors !== []){
             throw new FinalizersException($scopeName, $errors);
         }
     }

src/Tokenizer/src/EnumLocator.php

Spacing +10 added lines, -10 removed lines

@@ -13,18 +13,18 @@ 
 {
     public const INJECTOR = EnumLocatorInjector::class;
 
-    public function getEnums(object|string|null $target = null): array
+    public function getEnums(object | string | null $target = null): array
     {
-        if (!empty($target)) {
+        if (!empty($target)){
             $target = new \ReflectionClass($target);
         }
 
         $result = [];
-        foreach ($this->availableEnums() as $enum) {
-            try {
+        foreach ($this->availableEnums() as $enum){
+            try{
                 $reflection = $this->enumReflection($enum);
-            } catch (LocatorException $e) {
-                if ($this->debug) {
+            }catch (LocatorException $e){
+                if ($this->debug){
                     throw $e;
                 }
 
@@ -32,7 +32,7 @@ 
                 continue;
             }
 
-            if (!$this->isTargeted($reflection, $target) || $reflection->isInterface()) {
+            if (!$this->isTargeted($reflection, $target) || $reflection->isInterface()){
                 continue;
             }
 
@@ -51,7 +51,7 @@ 
     {
         $enums = [];
 
-        foreach ($this->availableReflections() as $reflection) {
+        foreach ($this->availableReflections() as $reflection){
             $enums = \array_merge($enums, $reflection->getEnums());
         }
 
@@ -65,11 +65,11 @@ 
      */
     protected function isTargeted(\ReflectionEnum $enum, \ReflectionClass $target = null): bool
     {
-        if ($target === null) {
+        if ($target === null){
             return true;
         }
 
-        if (!$target->isTrait()) {
+        if (!$target->isTrait()){
             //Target is interface or class
             /** @psalm-suppress RedundantCondition https://github.com/vimeo/psalm/issues/9489 */
             return $enum->isSubclassOf($target) || $enum->getName() === $target->getName();