spiral / framework

src/Filters/src/SchemaBuilder.php

Braces +21 added lines, -10 removed lines

@@ -70,18 +70,22 @@ 
     protected function buildMap(ReflectionEntity $filter): array
     {
         $schema = $filter->getProperty('schema', true);
-        if (empty($schema)) {
+        if (empty($schema))
+        {
             throw new SchemaException("Filter `{$filter->getName()}` does not define any schema");
         }
 
         $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] = [
                         FilterProvider::SOURCE => $source,
@@ -102,25 +106,30 @@ 
                 continue;
             }
 
-            if (!is_array($definition) || count($definition) === 0) {
+            if (!is_array($definition) || count($definition) === 0)
+            {
                 throw new SchemaException(
                     "Invalid schema definition at `{$filter->getName()}`->`{$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 = strpos($origin, '.*') !== false || !empty($definition[self::ITERATE]);
                 $origin = rtrim($origin, '.*');
-            } else {
+            }
+            else
+            {
                 $origin = $field;
                 $iterate = true;
             }
 
-            if (!empty($definition[self::OPTIONAL]) && $definition[self::OPTIONAL]) {
+            if (!empty($definition[self::OPTIONAL]) && $definition[self::OPTIONAL])
+            {
                 $optional = true;
             }
 
@@ -133,7 +142,8 @@ 
                 FilterProvider::OPTIONAL => $optional,
             ];
 
-            if ($iterate) {
+            if ($iterate)
+            {
                 [$source, $origin] = $this->parseDefinition($field, $definition[self::ITERATE] ?? $origin);
 
                 $map[FilterProvider::ITERATE_SOURCE] = $source;
@@ -159,7 +169,8 @@ 
      */
     private function parseDefinition(string $field, string $definition): array
     {
-        if (strpos($definition, ':') === false) {
+        if (strpos($definition, ':') === false)
+        {
             return ['data', $definition ?? $field];
         }
 

src/Filters/src/Filter.php

Braces +26 added lines, -13 removed lines

@@ -160,10 +160,13 @@ 
      */
     public function getErrors(): array
     {
-        if ($this->errors === null) {
+        if ($this->errors === null)
+        {
             $this->errors = [];
-            foreach ($this->validator->withData($this)->getErrors() as $field => $error) {
-                if (is_string($error) && Translator::isMessage($error)) {
+            foreach ($this->validator->withData($this)->getErrors() as $field => $error)
+            {
+                if (is_string($error) && Translator::isMessage($error))
+                {
                     // translate error message
                     $error = $this->say($error);
                 }
@@ -195,36 +198,46 @@ 
      */
     protected function validateNested(array $errors): array
     {
-        foreach ($this->getFields(false) as $index => $value) {
-            if (isset($errors[$index])) {
+        foreach ($this->getFields(false) as $index => $value)
+        {
+            if (isset($errors[$index]))
+            {
                 //Invalid on parent level
                 continue;
             }
 
-            if ($value instanceof FilterInterface) {
+            if ($value instanceof FilterInterface)
+            {
                 $isOptional = $this->mappings[$index][FilterProvider::OPTIONAL] ?? false;
 
-                if ($isOptional && $this->getField($index) !== []) {
+                if ($isOptional && $this->getField($index) !== [])
+                {
                     continue;
                 }
 
-                if (!$value->isValid()) {
+                if (!$value->isValid())
+                {
                     $errors[$index] = $value->getErrors();
                     continue;
                 }
             }
 
             //Array of nested entities for validation
-            if (is_iterable($value)) {
-                foreach ($value as $nIndex => $nValue) {
-                    if ($nValue instanceof FilterInterface) {
+            if (is_iterable($value))
+            {
+                foreach ($value as $nIndex => $nValue)
+                {
+                    if ($nValue instanceof FilterInterface)
+                    {
                         $isOptional = $this->mappings[$index][FilterProvider::OPTIONAL] ?? false;
 
-                        if ($isOptional && $this->getField($nIndex) !== []) {
+                        if ($isOptional && $this->getField($nIndex) !== [])
+                        {
                             continue;
                         }
 
-                        if (!$nValue->isValid()) {
+                        if (!$nValue->isValid())
+                        {
                             $errors[$index][$nIndex] = $nValue->getErrors();
                         }
                     }