@amazeelabs/silverback-gutenberg 2.6.2

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergCardinalityValidatorTrait.php

@@ -0,0 +1,221 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+
+/**
+ * Cardinality validator helper.
+ */
+trait GutenbergCardinalityValidatorTrait {
+
+  /**
+   * Validates the cardinality of the inner blocks of a block.
+   *
+   * This helper can be called from the validateContent() method of a validator.
+   *
+   * Example to validate the cardinality of all inner blocks (any, no matter the name).
+   * @code
+   * [
+   *   'validationType' => GutenbergCardinalityValidatorInterface::CARDINALITY_ANY,
+   *   'min' => 0,
+   *   'max' => 3,
+   * ]
+   * @endcode
+   *
+   * Example to validate by block name:
+   * @code
+   * [
+   *   [
+   *     'blockName' => 'core/paragraph',
+   *     'blockLabel' => $this->t('Paragraph'),
+   *     'min' => 0,
+   *     'max' => 3,
+   *   ],
+   *   [
+   *     'blockName' => 'core/embed',
+   *     'blockLabel' => $this->t('Embed'),
+   *     'min' => 1,
+   *     'max' => 2,
+   *   ],
+   *   [
+   *     'blockName' => 'core/block',
+   *     'blockLabel' => $this->t('Reusable block'),
+   *     'min' => 1,
+   *     'max' => GutenbergCardinalityValidatorInterface::CARDINALITY_UNLIMITED,
+   *   ],
+   * ];
+   * @endcode
+   *
+   * @param array $block
+   * @param array $expected_children
+   *
+   * @return array
+   */
+  public function validateCardinality(array $block, array $expected_children): array {
+    // Nothing to validate.
+    if (empty($expected_children)) {
+      return [
+        'is_valid' => TRUE,
+        'message' => '',
+      ];
+    }
+
+    // Check if the quantity validation is any block, no matter the name.
+    if (
+      !empty($expected_children['validationType']) &&
+      $expected_children['validationType'] === GutenbergCardinalityValidatorInterface::CARDINALITY_ANY) {
+      return $this->validateAnyInnerBlocks($block, $expected_children);
+    }
+
+    // Exit early if there are no inner blocks.
+    if (empty($block['innerBlocks'])) {
+      return $this->validateEmptyInnerBlocks($expected_children);
+    }
+
+    // Count blocks, then check if the quantity for each is correct.
+    $countInnerBlockInstances = [];
+    foreach ($block['innerBlocks'] as $innerBlock) {
+      if (!isset($countInnerBlockInstances[$innerBlock['blockName']])) {
+        $countInnerBlockInstances[$innerBlock['blockName']] = 0;
+      }
+      $countInnerBlockInstances[$innerBlock['blockName']]++;
+    }
+
+    foreach ($expected_children as $child) {
+      if (!isset($countInnerBlockInstances[$child['blockName']]) && $child['min'] > 0) {
+        $message = $this->getExpectedQuantityErrorMessage($child);
+        return [
+          'is_valid' => FALSE,
+          'message' => $message,
+        ];
+      }
+      // Minimum is set to 0, so we don't care if the block is not present.
+      if (!isset($countInnerBlockInstances[$child['blockName']]) && $child['min'] === 0) {
+        return [
+          'is_valid' => TRUE,
+          'message' => '',
+        ];
+      }
+      if ($countInnerBlockInstances[$child['blockName']] < $child['min']) {
+        return [
+          'is_valid' => FALSE,
+          'message' => \Drupal::translation()->formatPlural($child['min'],
+            '%label: at least @min block is required.',
+            '%label: at least @min blocks are required.',
+            [
+              '%label' => $child['blockLabel'],
+              '@min' => $child['min'],
+            ]),
+        ];
+      }
+      if ($child['max'] !== GutenbergCardinalityValidatorInterface::CARDINALITY_UNLIMITED && $countInnerBlockInstances[$child['blockName']] > $child['max']) {
+        return [
+          'is_valid' => FALSE,
+          'message' => \Drupal::translation()->formatPlural($child['max'],
+            '%label: at most @max block is allowed.',
+            '%label: at most @max blocks are allowed.',
+            [
+              '%label' => $child['blockLabel'],
+              '@max' => $child['max'],
+            ]),
+        ];
+      }
+    }
+
+    return [
+      'is_valid' => TRUE,
+      'message' => '',
+    ];
+  }
+
+  /**
+   * Check if it's fine to not have any inner blocks.
+   *
+   * Returns a message with all expected children blocks if needed.
+   *
+   * @param array $expected_children
+   *
+   * @return array|void
+   */
+  private function validateEmptyInnerBlocks (array $expected_children): array {
+    $missingBlocksMessages = [];
+    foreach ($expected_children as $child) {
+      if ($child['min'] > 0) {
+        $message = $this->getExpectedQuantityErrorMessage($child);
+        $missingBlocksMessages[] = $message;
+      }
+    }
+    if (!empty($missingBlocksMessages)) {
+      $errorMessage = t('Required blocks are missing.');
+      $errorMessage .= ' ' . implode(' ', $missingBlocksMessages);
+      return [
+        'is_valid' => FALSE,
+        'message' => $errorMessage,
+      ];
+    }
+
+    return [
+      'is_valid' => TRUE,
+      'message' => '',
+    ];
+  }
+
+  /**
+   * Validates the cardinality of any inner blocks.
+   *
+   * @param array $inner_blocks
+   * @param array $expected_children
+   *
+   * @return array
+   */
+  private function validateAnyInnerBlocks(array $inner_blocks, array $expected_children): array {
+    $min = $expected_children['min'];
+    $max = $expected_children['max'];
+    $count = count($inner_blocks['innerBlocks']);
+    if ($count < $min) {
+      return [
+        'is_valid' => FALSE,
+        'message' => \Drupal::translation()->formatPlural($min,
+          'At least @min block is required.',
+          'At least @min blocks are required.',
+          [
+            '@min' => $min,
+          ]),
+      ];
+    }
+    if ($max !== GutenbergCardinalityValidatorInterface::CARDINALITY_UNLIMITED && $count > $max) {
+      return [
+        'is_valid' => FALSE,
+        'message' => \Drupal::translation()->formatPlural($max,
+          'At most @max block is allowed.',
+          'At most @max blocks are allowed.',
+          [
+            '@max' => $max,
+          ]),
+      ];
+    }
+
+    return [
+      'is_valid' => TRUE,
+      'message' => '',
+    ];
+  }
+
+  private function getExpectedQuantityErrorMessage(array $child_block): string|TranslatableMarkup {
+    $messageParams = [
+      '%label' => $child_block['blockLabel'],
+      '@min' => $child_block['min'],
+      '@max' => $child_block['max'] > 0 ? $child_block['max'] : t('unlimited'),
+    ];
+    $result = t('%label: there should be between @min and @max blocks.', $messageParams);
+    if ($child_block['min'] === $child_block['max']) {
+      $result = \Drupal::translation()->formatPlural($child_block['min'],
+        '%label: there should be exactly @min block.',
+        '%label: there should be exactly @min blocks.',
+        $messageParams);
+    }
+    return $result;
+  }
+
+}

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergValidatorBase.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+/**
+ * Base class for all the Gutenberg validators.
+ */
+abstract class GutenbergValidatorBase implements GutenbergValidatorInterface {
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validateContent(array $block = []): array {
+    return [];
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validatedFields(array $block = []): array {
+    return [];
+  }
+
+}

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergValidatorInterface.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+/**
+ * Gutenberg validator plugins interface
+ */
+interface GutenbergValidatorInterface {
+
+  /**
+   * Checks if the validator should apply on a block.
+   *
+   * @param array $block
+   *  A gutenberg block (generated for example by the Gutenberg BlockParser
+   *  class).
+   *
+   * @return bool
+   */
+  public function applies(array $block): bool;
+
+  /**
+   * Returns an array with the validation rules for each field that should be
+   * performed on the Gutenberg block. The keys of the array represent the block
+   * properties (field names) and the values are arrays with validation rule
+   * plugins that should be applied for that field, as well as, optionally, the
+   * human-readable label of the field.
+   *
+   * Example:
+   * @code
+   * array(
+   *   'title' => array(
+   *     'field_label' => t('Title'),
+   *     'rules' => array('gutenberg_rule_required'),
+   *    ),
+   *   'caption' => array(
+   *     'field_label' => t('Caption'),
+   *     'rules' => array('gutenberg_rule_required_caption', 'some_other_rule_plugin'),
+   *   ),
+   * );
+   * @endcode
+   *
+   * @return array
+   */
+  public function validatedFields(array $block = []): array;
+
+  /**
+   * Validates the content of a block. Useful in case the validator should
+   * perform a more complex validation logic, on the entire block, which cannot
+   * be covered by the existing validation rules.
+   *
+   * Use isValid and message keys in the array to display a message
+   *
+   * Example:
+   * @code
+   * array(
+   *   'is_valid' => FALSE,
+   *   'message' => 'Field name is not valid'
+   * );
+   * @endcode
+   *
+   * @return array
+   */
+  public function validateContent(array $block = []): array;
+
+}

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergValidatorManager.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Plugin\DefaultPluginManager;
+
+/**
+ * Provides a Gutenberg Validator plugin manager.
+ */
+class GutenbergValidatorManager extends DefaultPluginManager {
+
+  /**
+   * Constructs a GutenbergValidatorManager object.
+   *
+   * @param \Traversable $namespaces
+   *   An object that implements \Traversable which contains the root paths
+   *   keyed by the corresponding namespace to look for plugin implementations.
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+   *   Cache backend instance to use.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler to invoke the alter hook with.
+   */
+  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler) {
+    parent::__construct(
+      'Plugin/Validation/GutenbergValidator',
+      $namespaces,
+      $module_handler,
+      'Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorInterface',
+      'Drupal\silverback_gutenberg\Annotation\GutenbergValidator'
+    );
+    $this->alterInfo('gutenberg_validator_info');
+    $this->setCacheBackend($cache_backend, 'gutenberg_validator_info_plugins');
+  }
+
+}

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergValidatorRuleInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+/**
+ * Gutenberg validator rule plugins interface.
+ */
+interface GutenbergValidatorRuleInterface {
+
+  /**
+   * Validates a value.
+   *
+   * @param $value
+   * @param $fieldLabel
+   *
+   * @return bool
+   */
+  public function validate($value, $fieldLabel): bool|string;
+
+}

package/drupal/silverback_gutenberg/src/GutenbergValidation/GutenbergValidatorRuleManager.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\GutenbergValidation;
+
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Plugin\DefaultPluginManager;
+
+/**
+ * Provides a Gutenberg Validator Rule plugin manager.
+ */
+class GutenbergValidatorRuleManager extends DefaultPluginManager {
+
+  /**
+   * Constructs a GutenbergValidatorRuleManager object.
+   *
+   * @param \Traversable $namespaces
+   *   An object that implements \Traversable which contains the root paths
+   *   keyed by the corresponding namespace to look for plugin implementations.
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+   *   Cache backend instance to use.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler to invoke the alter hook with.
+   */
+  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler) {
+    parent::__construct(
+      'Plugin/Validation/GutenbergValidatorRule',
+      $namespaces,
+      $module_handler,
+      'Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleInterface',
+      'Drupal\silverback_gutenberg\Annotation\GutenbergValidatorRule'
+    );
+    $this->alterInfo('gutenberg_validator_rule_info');
+    $this->setCacheBackend($cache_backend, 'gutenberg_validator_rule_info_plugins');
+  }
+
+}