spiral / framework

src/Filters/src/Model/Mapper/SetterRegistry.php

Spacing +1 added lines, -1 removed lines

@@ -11,7 +11,7 @@
 
     public function __construct(array $setters = [])
     {
-        foreach ($setters as $setter) {
+        foreach ($setters as $setter){
             $this->register($setter);
         }
     }

src/Filters/src/Model/Mapper/Uuid.php

Spacing +5 added lines, -5 removed lines

@@ -13,7 +13,7 @@ 
 
     public function supports(\ReflectionNamedType $type): bool
     {
-        if ($this->interfaceExists === null) {
+        if ($this->interfaceExists === null){
             $this->interfaceExists = \interface_exists(UuidInterface::class);
         }
 
@@ -27,16 +27,16 @@ 
 
     private function implements(string $haystack, string $interface): bool
     {
-        if ($haystack === $interface) {
+        if ($haystack === $interface){
             return true;
         }
 
-        foreach ((array)\class_implements($haystack) as $implements) {
-            if ($implements === $interface) {
+        foreach ((array)\class_implements($haystack) as $implements){
+            if ($implements === $interface){
                 return true;
             }
 
-            if (self::implements($implements, $interface)) {
+            if (self::implements($implements, $interface)){
                 return true;
             }
         }

src/Filters/src/Model/Schema/Builder.php

Spacing +11 added lines, -11 removed lines

@@ -42,18 +42,18 @@ 
      */
     public function makeSchema(string $name, array $schema): array
     {
-        if (empty($schema)) {
+        if (empty($schema)){
             throw new SchemaException(\sprintf('Filter `%s` does not define any schema', $name));
         }
 
         $result = [];
-        foreach ($schema as $field => $definition) {
+        foreach ($schema as $field => $definition){
             $optional = false;
 
             // short definition
-            if (\is_string($definition)) {
+            if (\is_string($definition)){
                 // simple scalar field definition
-                if (!\class_exists($definition)) {
+                if (!\class_exists($definition)){
                     [$source, $origin] = $this->parseDefinition($field, $definition);
                     $result[$field] = [
                         self::SCHEMA_SOURCE => $source,
@@ -74,25 +74,25 @@ 
                 continue;
             }
 
-            if (!\is_array($definition) || $definition === []) {
+            if (!\is_array($definition) || $definition === []){
                 throw new SchemaException(
                     \sprintf('Invalid schema definition at `%s`->`%s`', $name, $field)
                 );
             }
 
             // complex definition
-            if (!empty($definition[self::ORIGIN])) {
+            if (!empty($definition[self::ORIGIN])){
                 $origin = $definition[self::ORIGIN];
 
                 // [class, 'data:something.*'] vs [class, 'data:something']
                 $iterate = \str_contains((string)$origin, '.*') || !empty($definition[self::ITERATE]);
                 $origin = \rtrim($origin, '.*');
-            } else {
+            }else{
                 $origin = $field;
                 $iterate = true;
             }
 
-            if (!empty($definition[self::OPTIONAL])) {
+            if (!empty($definition[self::OPTIONAL])){
                 $optional = true;
             }
 
@@ -105,7 +105,7 @@ 
                 self::SCHEMA_OPTIONAL => $optional,
             ];
 
-            if ($iterate) {
+            if ($iterate){
                 [$source, $origin] = $this->parseDefinition($field, $definition[self::ITERATE] ?? $origin);
 
                 $map[self::SCHEMA_ITERATE_SOURCE] = $source;
@@ -137,11 +137,11 @@ 
             'path',
             'remoteAddress',
             'uri',
-        ], true)) {
+        ], true)){
             return [$definition, $field];
         }
 
-        if (!\str_contains($definition, ':')) {
+        if (!\str_contains($definition, ':')){
             return ['data', empty($definition) ? $field : $definition];
         }
 

src/Framework/Bootloader/Security/FiltersBootloader.php

Spacing +2 added lines, -2 removed lines

@@ -43,7 +43,7 @@ 
         private readonly ContainerInterface $container,
         private readonly BinderInterface $binder,
         private readonly ConfiguratorInterface $config
-    ) {
+    ){
     }
 
     /**
@@ -93,7 +93,7 @@ 
         ?EventDispatcherInterface $dispatcher = null
     ): FilterProvider {
         $core = new InterceptableCore(new Core(), $dispatcher);
-        foreach ($config->getInterceptors() as $interceptor) {
+        foreach ($config->getInterceptors() as $interceptor){
             $core->addInterceptor($container->get($interceptor));
         }
 

src/Filters/src/Model/FilterProvider.php

Spacing +4 added lines, -4 removed lines

@@ -23,7 +23,7 @@ 
         private readonly ContainerInterface $container,
         private readonly ResolverInterface $resolver,
         private readonly CoreInterface $core
-    ) {
+    ){
     }
 
     public function createFilter(string $name, InputInterface $input): FilterInterface
@@ -34,7 +34,7 @@ 
         $filter = $this->createFilterInstance($name);
         [$mappingSchema, $errors, $setters, $optionalFilters] = $attributeMapper->map($filter, $input);
 
-        if ($filter instanceof HasFilterDefinition) {
+        if ($filter instanceof HasFilterDefinition){
             $mappingSchema = \array_merge(
                 $mappingSchema,
                 $filter->filterDefinition()->mappingSchema()
@@ -48,7 +48,7 @@ 
         \assert($schemaBuilder instanceof Builder);
 
         $schema = $schemaBuilder->makeSchema($name, $mappingSchema);
-        foreach ($optionalFilters as $optionalFilter) {
+        foreach ($optionalFilters as $optionalFilter){
             $schema[$optionalFilter][Builder::SCHEMA_OPTIONAL] = true;
         }
 
@@ -66,7 +66,7 @@ 
         $class = new \ReflectionClass($name);
 
         $args = [];
-        if ($constructor = $class->getConstructor()) {
+        if ($constructor = $class->getConstructor()){
             $args = $this->resolver->resolveArguments($constructor);
         }
 

src/Filters/src/Model/Mapper/Mapper.php

Spacing +4 added lines, -4 removed lines

@@ -13,7 +13,7 @@ 
 {
     public function __construct(
         private readonly SetterRegistryInterface $registry
-    ) {
+    ){
     }
 
     /**
@@ -22,9 +22,9 @@ 
     public function setValue(FilterInterface $filter, \ReflectionProperty $property, mixed $value): void
     {
         $type = $property->getType();
-        if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()) {
-            foreach ($this->registry->getSetters() as $setter) {
-                if ($setter->supports($type)) {
+        if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()){
+            foreach ($this->registry->getSetters() as $setter){
+                if ($setter->supports($type)){
                     $setter->setValue($filter, $property, $value);
                     return;
                 }

src/Filters/src/Model/Schema/AttributeMapper.php

Spacing +19 added lines, -19 removed lines

@@ -21,7 +21,7 @@ 
         private readonly FilterProviderInterface $provider,
         private readonly ReaderInterface $reader,
         private readonly Mapper $mapper
-    ) {
+    ){
     }
 
     /**
@@ -35,53 +35,53 @@ 
         $optionalFilters = [];
         $class = new \ReflectionClass($filter);
 
-        foreach ($class->getProperties() as $property) {
+        foreach ($class->getProperties() as $property){
             /** @var object $attribute */
-            foreach ($this->reader->getPropertyMetadata($property) as $attribute) {
-                if ($attribute instanceof AbstractInput) {
+            foreach ($this->reader->getPropertyMetadata($property) as $attribute){
+                if ($attribute instanceof AbstractInput){
                     $this->setValue($filter, $property, $attribute->getValue($input, $property));
                     $schema[$property->getName()] = $attribute->getSchema($property);
-                } elseif ($attribute instanceof NestedFilter) {
+                } elseif ($attribute instanceof NestedFilter){
                     $prefix = $attribute->prefix ?? $property->name;
-                    try {
+                    try{
                         $value = $this->provider->createFilter(
                             $attribute->class,
                             $input->withPrefix($prefix)
                         );
 
                         $this->setValue($filter, $property, $value);
-                    } catch (ValidationException $e) {
-                        if ($this->allowsNull($property)) {
+                    }catch (ValidationException $e){
+                        if ($this->allowsNull($property)){
                             $this->setValue($filter, $property, null);
                             $optionalFilters[] = $property->getName();
-                        } else {
+                        }else{
                             $errors[$prefix] = $e->errors;
                         }
                     }
 
                     $schema[$property->getName()] = $attribute->getSchema($property);
-                } elseif ($attribute instanceof NestedArray) {
+                } elseif ($attribute instanceof NestedArray){
                     $values = $attribute->getValue($input, $property);
                     $propertyValues = [];
 
                     $prefix = $attribute->input->key ?? $attribute->prefix ?? $property->getName();
 
-                    if (\is_array($values)) {
-                        foreach (\array_keys($values) as $key) {
-                            try {
+                    if (\is_array($values)){
+                        foreach (\array_keys($values) as $key){
+                            try{
                                 $propertyValues[$key] = $this->provider->createFilter(
                                     $attribute->class,
-                                    $input->withPrefix($prefix . '.' . $key)
+                                    $input->withPrefix($prefix.'.'.$key)
                                 );
-                            } catch (ValidationException $e) {
+                            }catch (ValidationException $e){
                                 $errors[$property->getName()][$key] = $e->errors;
                             }
                         }
                     }
 
                     $this->setValue($filter, $property, $propertyValues);
-                    $schema[$property->getName()] = [$attribute->class, $prefix . '.*'];
-                } elseif ($attribute instanceof Setter) {
+                    $schema[$property->getName()] = [$attribute->class, $prefix.'.*'];
+                } elseif ($attribute instanceof Setter){
                     $setters[$property->getName()][] = $attribute;
                 }
             }
@@ -92,13 +92,13 @@ 
 
     private function setValue(FilterInterface $filter, \ReflectionProperty $property, mixed $value): void
     {
-        if ($value === null) {
+        if ($value === null){
             return;
         }
 
         $setters = $this->reader->getPropertyMetadata($property, Setter::class);
 
-        foreach ($setters as $setter) {
+        foreach ($setters as $setter){
             $value = $setter->updateValue($value);
         }
 

src/Filters/src/Model/Schema/InputMapper.php

Spacing +15 added lines, -15 removed lines

@@ -13,7 +13,7 @@ 
 {
     public function __construct(
         private readonly FilterProviderInterface $provider
-    ) {
+    ){
     }
 
     public function map(array $mappingSchema, InputInterface $input, array $setters = []): array
@@ -21,13 +21,13 @@ 
         $errors = [];
         $result = [];
 
-        foreach ($mappingSchema as $field => $map) {
-            if (empty($map[Builder::SCHEMA_FILTER])) {
+        foreach ($mappingSchema as $field => $map){
+            if (empty($map[Builder::SCHEMA_FILTER])){
                 $value = $input->getValue($map[Builder::SCHEMA_SOURCE], $map[Builder::SCHEMA_ORIGIN]);
 
-                if ($value !== null) {
+                if ($value !== null){
                     /** @var Setter $setter */
-                    foreach ($setters[$field] ?? [] as $setter) {
+                    foreach ($setters[$field] ?? [] as $setter){
                         $value = $setter->updateValue($value);
                     }
 
@@ -37,12 +37,12 @@ 
             }
 
             $nested = $map[Builder::SCHEMA_FILTER];
-            if (empty($map[Builder::SCHEMA_ARRAY])) {
+            if (empty($map[Builder::SCHEMA_ARRAY])){
                 // slicing down
-                try {
+                try{
                     $result[$field] = $this->provider->createFilter($nested, $input->withPrefix($map[Builder::SCHEMA_ORIGIN]));
-                } catch (ValidationException $e) {
-                    if ($map[Builder::SCHEMA_OPTIONAL]) {
+                }catch (ValidationException $e){
+                    if ($map[Builder::SCHEMA_OPTIONAL]){
                         $result[$field] = null;
                         continue;
                     }
@@ -54,10 +54,10 @@ 
             $values = [];
 
             // List of "key" => "location in request"
-            foreach ($this->iterate($map, $input) as $index => $origin) {
-                try {
+            foreach ($this->iterate($map, $input) as $index => $origin){
+                try{
                     $values[$index] = $this->provider->createFilter($nested, $input->withPrefix($origin));
-                } catch (ValidationException $e) {
+                }catch (ValidationException $e){
                     $errors[$field][$index] = $e->errors;
                 }
             }
@@ -78,12 +78,12 @@ 
             $schema[Builder::SCHEMA_ITERATE_ORIGIN]
         );
 
-        if (empty($values) || !\is_array($values)) {
+        if (empty($values) || !\is_array($values)){
             return [];
         }
 
-        foreach (\array_keys($values) as $key) {
-            yield $key => $schema[Builder::SCHEMA_ORIGIN] . '.' . $key;
+        foreach (\array_keys($values) as $key){
+            yield $key => $schema[Builder::SCHEMA_ORIGIN].'.'.$key;
         }
     }
 }