Fix states array creation

phpstan.neon.dist

@@ -30,8 +30,5 @@ parameters:
 			paths:
 				- */src/JsonForms/Definition/Control/ControlDefinition.php
 				- */src/JsonForms/Definition/Layout/LayoutDefinition.php
-		-
-			message: '#^Argument of an invalid type stdClass supplied for foreach, only iterables are supported.$#'
-			path: */src/Form/Control/ObjectArrayFactory.php
 		- '#^Method Drupal\\json_forms\\JsonForms\\Definition\\Control\\[^\s]+ControlDefinition::[^\s]+\(\) should return [^\s]+\|null but returns mixed.$#'
 	tmpDir: .phpstan

src/Form/Control/ArrayArrayFactory.php

@@ -32,6 +32,7 @@
 use Drupal\json_forms\JsonForms\Definition\Control\ArrayControlDefinition;
 use Drupal\json_forms\JsonForms\Definition\Control\ControlDefinition;
 use Drupal\json_forms\JsonForms\Definition\DefinitionInterface;
+use Drupal\json_forms\JsonForms\Definition\Layout\ArrayLayoutDefinition;
 use Drupal\json_forms\JsonForms\Definition\Layout\LayoutDefinition;
 
 final class ArrayArrayFactory extends AbstractConcreteFormArrayFactory {
@@ -185,7 +186,7 @@ private function buildTableHeader(LayoutDefinition $arrayLayoutDefinition): arra
     return $header;
   }
 
-  private function createLayoutDefinition(ArrayControlDefinition $definition): LayoutDefinition {
+  private function createLayoutDefinition(ArrayControlDefinition $definition): ArrayLayoutDefinition {
     // Note: We actually do not use "detail" as it is described in JSON Forms:
     // https://jsonforms.io/docs/uischema/controls#the-detail-option
     // Should we use another option name instead?
@@ -200,7 +201,9 @@ private function createLayoutDefinition(ArrayControlDefinition $definition): Lay
     Assertion::isInstanceOf($items, \stdClass::class);
     $arrayUiSchema->elements ??= $this->createElementSchemas($items);
 
-    return new LayoutDefinition($arrayUiSchema, $items, $definition->isUiReadonly());
+    return new ArrayLayoutDefinition(
+      $arrayUiSchema, $items, $definition->isUiReadonly(), $definition->getRootDefinition()
+    );
   }
 
   /**

src/Form/Control/ObjectArrayFactory.php

@@ -25,10 +25,8 @@
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\json_forms\Form\AbstractConcreteFormArrayFactory;
 use Drupal\json_forms\Form\FormArrayFactoryInterface;
-use Drupal\json_forms\JsonForms\Definition\Control\ControlDefinition;
 use Drupal\json_forms\JsonForms\Definition\Control\ObjectControlDefinition;
 use Drupal\json_forms\JsonForms\Definition\DefinitionInterface;
-use Drupal\json_forms\JsonForms\Definition\Layout\LayoutDefinition;
 
 final class ObjectArrayFactory extends AbstractConcreteFormArrayFactory {
 
@@ -40,39 +38,13 @@ public function createFormArray(
     FormStateInterface $formState,
     FormArrayFactoryInterface $formArrayFactory
   ): array {
-    Assertion::isInstanceOf($definition, ControlDefinition::class);
-    /** @var \Drupal\json_forms\JsonForms\Definition\Control\ControlDefinition $definition */
-    $definition = ObjectControlDefinition::fromDefinition($definition);
-    /** @var \Drupal\json_forms\JsonForms\Definition\Control\ObjectControlDefinition $definition */
+    Assertion::isInstanceOf($definition, ObjectControlDefinition::class);
 
-    $layoutSchema = $this->createLayoutSchema($definition);
-    $layoutDefinition = new LayoutDefinition(
-      $layoutSchema,
-      $definition->getPropertySchema(),
-      $definition->isUiReadonly()
-    );
-
-    return $formArrayFactory->createFormArray($layoutDefinition, $formState);
+    return $formArrayFactory->createFormArray($definition->getLayoutDefinition(), $formState);
   }
 
   public function supportsDefinition(DefinitionInterface $definition): bool {
-    return $definition instanceof ControlDefinition && 'object' === $definition->getType();
-  }
-
-  private function createLayoutSchema(ObjectControlDefinition $definition): \stdClass {
-    $layoutSchema = (object) [
-      'type' => 'VerticalLayout',
-      'elements' => [],
-    ];
-
-    foreach ($definition->getProperties() as $propertyName => $propertySchema) {
-      $layoutSchema->elements[] = (object) [
-        'type' => 'Control',
-        'scope' => '#/properties/' . $propertyName,
-      ];
-    }
-
-    return $layoutSchema;
+    return $definition instanceof ObjectControlDefinition;
   }
 
 }

src/Form/Control/Rule/StatesArrayFactory.php

@@ -21,9 +21,22 @@
 
 namespace Drupal\json_forms\Form\Control\Rule;
 
-use Drupal\json_forms\Form\Control\Util\FormPropertyUtil;
-use Drupal\json_forms\JsonForms\ScopePointer;
-
+use Drupal\json_forms\JsonForms\Definition\Control\ObjectControlDefinition;
+use Drupal\json_forms\JsonForms\Definition\DefinitionInterface;
+use Drupal\json_forms\JsonForms\Definition\Layout\LayoutDefinition;
+
+/**
+ * This class tries to create a Drupal states array from a JSON Forms rule.
+ * Though, not everything in a condition schema can be mapped to Drupal
+ * functionality.
+ *
+ * Note: In JSON Forms controls inside of arrays cannot reference properties
+ * outside of that array.
+ * See: https://github.com/eclipsesource/jsonforms/issues/2094.
+ *
+ * @see https://jsonforms.io/docs/uischema/rules
+ * @see https://www.drupal.org/docs/drupal-apis/form-api/conditional-form-fields
+ */
 final class StatesArrayFactory implements StatesArrayFactoryInterface {
 
   private StatesBuilder $statesBuilder;
@@ -35,49 +48,72 @@ public function __construct() {
   /**
    * @phpstan-return array<string, mixed>
    */
-  public function createStatesArray(\stdClass $rule): array {
+  public function createStatesArray(DefinitionInterface $definition): array {
+    $rule = $definition->getRule();
+    if (NULL === $rule) {
+      return [];
+    }
+
+    $rootDefinition = $definition->getRootDefinition();
+    if ($rootDefinition instanceof ObjectControlDefinition) {
+      $rootDefinition = $rootDefinition->getLayoutDefinition();
+    }
+    elseif (!$rootDefinition instanceof LayoutDefinition) {
+      return [];
+    }
+
     $this->statesBuilder->clear();
     $this->addStates(
       $rule->effect,
-      $this->getFieldName($rule->condition->scope),
-      $rule->condition->schema,
+      $rootDefinition,
+      $rule->condition->scope,
+      $rule->condition->schema
     );
 
     return $this->statesBuilder->toArray();
   }
 
-  private function getFieldName(string $scope): string {
-    return FormPropertyUtil::getFormNameForPropertyPath(ScopePointer::new($scope)->getPropertyPath());
-  }
-
   private function addStates(
     string $effect,
-    string $fieldName,
-    \stdClass $schema,
+    LayoutDefinition $rootDefinition,
+    string $scope,
+    \stdClass $conditionSchema,
     bool $negate = FALSE,
     bool $isContains = FALSE
   ): void {
-    if (property_exists($schema, 'not')) {
-      $this->addStates($effect, $fieldName, $schema->not, !$negate, $isContains);
+    if (property_exists($conditionSchema, 'const')) {
+      $controlDefinition = $rootDefinition->findControlDefinition($scope);
+      if (NULL !== $controlDefinition) {
+        $this->statesBuilder->add($effect, $controlDefinition, $conditionSchema->const, $negate, $isContains);
+      }
     }
 
-    if (property_exists($schema, 'const')) {
-      $this->statesBuilder->add($effect, $fieldName, $schema->const, $negate, $isContains);
+    if (property_exists($conditionSchema, 'enum')) {
+      $controlDefinition = $rootDefinition->findControlDefinition($scope);
+      if (NULL !== $controlDefinition) {
+        $this->statesBuilder->add($effect, $controlDefinition, $conditionSchema->enum, $negate, $isContains);
+      }
     }
 
-    if (property_exists($schema, 'enum')) {
-      $this->statesBuilder->add($effect, $fieldName, $schema->enum, $negate, $isContains);
+    if (property_exists($conditionSchema, 'not')) {
+      $this->addStates($effect, $rootDefinition, $scope, $conditionSchema->not, !$negate, $isContains);
     }
 
-    if (property_exists($schema, 'properties')) {
-      foreach ($schema->properties as $property => $propertySchema) {
-        $propertyFieldName = $fieldName . '[' . $property . ']';
-        $this->addStates($effect, $propertyFieldName, $propertySchema, $negate, $isContains);
-      }
+    if (property_exists($conditionSchema, 'contains')) {
+      $this->addStates($effect, $rootDefinition, $scope, $conditionSchema->contains, $negate, TRUE);
     }
 
-    if (property_exists($schema, 'contains')) {
-      $this->addStates($effect, $fieldName, $schema->contains, $negate, TRUE);
+    if (property_exists($conditionSchema, 'properties')) {
+      foreach ($conditionSchema->properties as $property => $propertyConditionSchema) {
+        $this->addStates(
+          $effect,
+          $rootDefinition,
+          "$scope/properties/$property",
+          $propertyConditionSchema,
+          $negate,
+          $isContains
+        );
+      }
     }
   }
 

src/Form/Control/Rule/StatesArrayFactoryInterface.php

@@ -21,11 +21,13 @@
 
 namespace Drupal\json_forms\Form\Control\Rule;
 
+use Drupal\json_forms\JsonForms\Definition\DefinitionInterface;
+
 interface StatesArrayFactoryInterface {
 
   /**
    * @phpstan-return array<string, mixed>
    */
-  public function createStatesArray(\stdClass $rule): array;
+  public function createStatesArray(DefinitionInterface $definition): array;
 
 }

src/Form/Control/Rule/StatesBuilder.php

@@ -21,6 +21,10 @@
 
 namespace Drupal\json_forms\Form\Control\Rule;
 
+use Drupal\json_forms\Form\Control\Util\FormPropertyUtil;
+use Drupal\json_forms\JsonForms\Definition\Control\ControlDefinition;
+use Drupal\json_forms\JsonForms\ScopePointer;
+
 /**
  * @phpstan-type statesT array<string, array<string|int, array<array<string, mixed>|'and'|'or'|'xor'>>>
  * @phpstan-type conditionT array{checked: bool}|array{empty: bool}|array{value: scalar}
@@ -37,11 +41,12 @@ final class StatesBuilder {
    */
   public function add(
     string $effect,
-    string $fieldName,
+    ControlDefinition $definition,
     $value,
     bool $negate,
     bool $isContains
   ): self {
+    $fieldName = $this->getFieldName($definition->getFullScope());
     foreach ($this->getStates($effect, $negate) as $state) {
       if ($isContains) {
         $this->states[$state][] = $this->buildContainsCondition($fieldName, $value);
@@ -52,7 +57,7 @@ public function add(
           $this->states[$state][$selector][] = 'and';
         }
 
-        $this->states[$state][$selector][] = $this->buildCondition($value);
+        $this->states[$state][$selector][] = $this->buildCondition($definition, $value);
       }
     }
 
@@ -63,6 +68,13 @@ public function clear(): void {
     $this->states = [];
   }
 
+  /**
+   * @phpstan-return statesT
+   */
+  public function toArray(): array {
+    return $this->states;
+  }
+
   /**
    * @phpstan-return array<string>
    *
@@ -88,40 +100,51 @@ private function getStates(string $effect, bool $negate): array {
     }
   }
 
+  private function getFieldName(string $scope): string {
+    return '#' === $scope ? ''
+      : FormPropertyUtil::getFormNameForPropertyPath(ScopePointer::new($scope)->getPropertyPath());
+  }
+
   /**
    * @phpstan-param scalar|array<scalar>|null $value
    *
    * @phpstan-return conditionT|array<conditionT|'or'>
    */
-  private function buildCondition($value): array {
-    if (is_bool($value)) {
-      return [
-        ['checked' => $value],
-        'and',
-        ['value' => $value ? '1' : '0'],
-      ];
-    }
+  private function buildCondition(ControlDefinition $definition, $value): array {
+    if (is_array($value)) {
+      $condition = [];
+      foreach ($value as $v) {
+        if (!is_array($v)) {
+          /** @phpstan-var conditionT $subCondition */
+          $subCondition = $this->buildCondition($definition, $v);
+          $condition[] = $subCondition;
+          $condition[] = 'or';
+        }
+      }
+      array_pop($condition);
 
-    if (NULL === $value) {
-      return ['empty' => TRUE];
+      return $condition;
     }
 
-    if (!is_array($value)) {
-      return ['value' => (string) $value];
+    if (is_bool($value)) {
+      if ('boolean' === $definition->getType() && 'radio' !== $definition->getControlFormat()) {
+        // checkbox.
+        return ['checked' => $value];
+      }
+
+      return ['value' => $value ? '1' : '0'];
     }
 
-    $condition = [];
-    foreach ($value as $v) {
-      if (!is_array($v)) {
-        /** @phpstan-var conditionT $subCondition */
-        $subCondition = $this->buildCondition($v);
-        $condition[] = $subCondition;
-        $condition[] = 'or';
-      }
+    $value = (string) $value;
+    if ('' === $value) {
+      return [
+        ['empty' => TRUE],
+        'or',
+        ['value' => $value],
+      ];
     }
-    array_pop($condition);
 
-    return $condition;
+    return ['value' => $value];
   }
 
   /**
@@ -152,11 +175,4 @@ private function buildContainsCondition(string $fieldName, $value): array {
     return $condition;
   }
 
-  /**
-   * @phpstan-return statesT
-   */
-  public function toArray(): array {
-    return $this->states;
-  }
-
 }

src/Form/Control/Util/BasicFormPropertiesFactory.php

@@ -58,7 +58,7 @@ public static function createBasicProperties(ControlDefinition $definition): arr
 
     if (NULL !== $definition->getRule()) {
       $statesArrayFactory = new StatesArrayFactory();
-      $form['#states'] = $statesArrayFactory->createStatesArray($definition->getRule());
+      $form['#states'] = $statesArrayFactory->createStatesArray($definition);
     }
 
     // Custom option to hide labels, so they are not shown in the form by

src/Form/Layout/AbstractLayoutArrayFactory.php

@@ -55,7 +55,7 @@ public function createFormArray(
     DescriptionDisplayUtil::handleDescriptionDisplay($form, $definition->getOptionsValue('descriptionDisplay'));
 
     if (NULL !== $definition->getRule()) {
-      $form['#states'] = $this->statesArrayFactory->createStatesArray($definition->getRule());
+      $form['#states'] = $this->statesArrayFactory->createStatesArray($definition);
     }
 
     return array_merge($form, $this->createElementsFormArray($definition, $formState, $formArrayFactory));

src/Form/Markup/HtmlMarkupArrayFactory.php

@@ -56,7 +56,7 @@ public function createFormArray(
     ];
 
     if (NULL !== $definition->getRule()) {
-      $element['#states'] = $this->statesArrayFactory->createStatesArray($definition->getRule());
+      $element['#states'] = $this->statesArrayFactory->createStatesArray($definition);
     }
 
     return $element;