@amazeelabs/silverback-gutenberg 2.6.2

package/drupal/silverback_gutenberg/src/Plugin/Validation/GutenbergValidatorRule/Email.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Validation\GutenbergValidatorRule;
+
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleInterface;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+
+/**
+ * @GutenbergValidatorRule(
+ *   id="email",
+ *   label = @Translation("Email")
+ * )
+ */
+class Email implements GutenbergValidatorRuleInterface {
+
+  use StringTranslationTrait;
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validate($value, $fieldLabel): bool|string {
+    if (!empty($value) && !\Drupal::service('email.validator')->isValid($value)) {
+      return $this->t('%field is not valid.', ['%field' => $fieldLabel]);
+    }
+    return TRUE;
+  }
+
+}

package/drupal/silverback_gutenberg/src/Plugin/Validation/GutenbergValidatorRule/Required.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Plugin\Validation\GutenbergValidatorRule;
+
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleInterface;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+
+/**
+ * @GutenbergValidatorRule(
+ *   id="required",
+ *   label = @Translation("Required")
+ * )
+ */
+class Required implements GutenbergValidatorRuleInterface {
+
+  use StringTranslationTrait;
+  public $requiredMessage = '%field field is required.';
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validate($value, $fieldLabel): bool|string {
+    if (empty($value) || $value === '_none') {
+      return $this->t($this->requiredMessage, ['%field' => $fieldLabel]);
+    }
+    return TRUE;
+  }
+
+}

package/drupal/silverback_gutenberg/src/ReferencedContentExtractor.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Drupal\silverback_gutenberg;
+
+class ReferencedContentExtractor {
+
+  /**
+   * Given an array of Gutenberg blocks, it returns all the referenced content
+   * based on specific entity type and uuid attributes.
+   *
+   * @param array $gutenbergBlocks
+   *  An array of parsed gutenberg blocks.
+   * @param string $entityTypeAttribute
+   *  The attribute name which identifies the entity type.
+   * @param string $uuidAttribute
+   *  The attribute name which identifies the uuid.
+   * @return array
+   */
+  public function getTargetEntities(
+    array $gutenbergBlocks,
+    string $entityTypeAttribute = 'entityType',
+    string $uuidAttribute = 'uuid'
+  ) {
+    $targetEntities = [];
+    $this->extractReferencesFromGutenbergBlocks($gutenbergBlocks, $entityTypeAttribute, $uuidAttribute, $targetEntities);
+    return $targetEntities;
+  }
+
+  /**
+   * Recursively extracts the content that is referenced inside an array of
+   * Gutenberg blocks. This is basically a helper for the public
+   * getTargetEntities() method.
+   *
+   * @param array $blocks
+   *  An array of parsed gutenberg blocks.
+   * @param string $entityTypeAttribute
+   *  The attribute name which identifies the entity type.
+   * @param string $uuidAttribute
+   *  The attribute name which identifies the uuid.
+   * @param array $references
+   *  An array with all the extracted references until the current call.
+   * @return void
+   */
+  protected function extractReferencesFromGutenbergBlocks(
+    array $blocks,
+    string $entityTypeAttribute,
+    string $uuidAttribute,
+    array &$references
+  ) {
+    foreach ($blocks as $block) {
+      if (!empty($block['attrs'][$uuidAttribute])) {
+        $uuid = $block['attrs'][$uuidAttribute];
+        // The default entity type should be, for convenience, node.
+        $entityType = $block['attrs'][$entityTypeAttribute] ?? 'node';
+        // Usually, the uuid would be one single value, but we also support an
+        // array of values.
+        $uuidList = is_array($uuid) ? $uuid : [$uuid];
+        foreach ($uuidList as $uuidItem) {
+          $references[$entityType][$uuidItem] = $uuidItem;
+        }
+      }
+      if (!empty($block['innerBlocks'])) {
+        $this->extractReferencesFromGutenbergBlocks($block['innerBlocks'], $entityTypeAttribute, $uuidAttribute, $references);
+      }
+    }
+  }
+}

package/drupal/silverback_gutenberg/src/Routing/RouteSubscriber.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Routing;
+
+use Drupal\Core\Routing\RouteSubscriberBase;
+use Drupal\silverback_gutenberg\Controller\LinkitAutocomplete;
+use Symfony\Component\Routing\RouteCollection;
+
+class RouteSubscriber extends RouteSubscriberBase {
+
+  protected function alterRoutes(RouteCollection $collection) {
+    if ($route = $collection->get('gutenberg.content.search')) {
+      $route->setDefault('_controller', LinkitAutocomplete::class . '::search');
+    }
+  }
+
+}

package/drupal/silverback_gutenberg/src/Service/MediaService.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Drupal\silverback_gutenberg\Service;
+
+use Drupal\gutenberg\Service\MediaService as Original;
+use Drupal\media_library\MediaLibraryState;
+
+class MediaService extends Original {
+
+  public function renderDialog(array $media_types, array $media_bundles = NULL) {
+    // Instead of guessing media types as the parent method does, use given
+    // media types as media type IDs. So the blocks have full control over
+    // allowed media types.
+    // The default behavior is: get bundles by $media_types, then intersect them
+    // with $media_bundles.
+    // New behavior is: get bundles from $media_types, so we don't break
+    // projects using this module.
+    $media_bundles = $media_types;
+
+    $buildUi = $this->builder->buildUi(
+      MediaLibraryState::create('gutenberg.media_library.opener', array_unique($media_bundles), reset($media_bundles), 1)
+    );
+    $this->moduleHandler->alter('gutenberg_media_library_view', $buildUi);
+    return $this->renderer->render($buildUi);
+  }
+
+}

package/drupal/silverback_gutenberg/src/SilverbackGutenbergServiceProvider.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Drupal\silverback_gutenberg;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\Core\DependencyInjection\ServiceProviderBase;
+use Drupal\silverback_gutenberg\Normalizer\GutenbergContentEntityNormalizer;
+use Drupal\silverback_gutenberg\Service\MediaService;
+use Symfony\Component\DependencyInjection\Reference;
+
+class SilverbackGutenbergServiceProvider extends ServiceProviderBase {
+  public function alter(ContainerBuilder $container) {
+    if ($container->has('gutenberg.media_service')) {
+      $definition = $container->getDefinition('gutenberg.media_service');
+      $definition->setClass(MediaService::class);
+    }
+    if ($container->has('webform.message_manager')) {
+      $definition = $container->getDefinition('webform.message_manager');
+      $definition->setClass(WebformMessageManager::class);
+    }
+
+    if ($container->has('default_content.content_entity_normalizer')) {
+      $definition = $container->getDefinition('default_content.content_entity_normalizer');
+      $definition->setClass(GutenbergContentEntityNormalizer::class);
+      $definition->addArgument(new Reference('plugin.manager.block_mutator'));
+    }
+  }
+}

package/drupal/silverback_gutenberg/src/Utils.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\silverback_gutenberg;
+
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\FieldableEntityInterface;
+use Drupal\gutenberg\Controller\UtilsController;
+
+class Utils {
+
+  public static function getGutenbergFields(EntityInterface $entity): array {
+    if (!function_exists('_gutenberg_is_gutenberg_enabled') || !_gutenberg_is_gutenberg_enabled($entity)) {
+      return [];
+    }
+    if ($entity instanceof FieldableEntityInterface) {
+      $textFields = UtilsController::getEntityTextFields($entity);
+      if (empty($textFields)) {
+        return [];
+      }
+      // At the moment Gutenberg uses the first text field.
+      return [$textFields[0]];
+    }
+    return [];
+  }
+
+  public static function linkProcessor(): LinkProcessor {
+    return \Drupal::service(LinkProcessor::class);
+  }
+
+}

package/drupal/silverback_gutenberg/src/WebformMessageManager.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\silverback_gutenberg;
+
+use Drupal\webform\WebformMessageManager as Original;
+
+class WebformMessageManager extends Original {
+
+  public function build($key) {
+    $build = parent::build($key);
+
+    if (isset($build['#markup'])) {
+      /** @var \Drupal\silverback_gutenberg\LinkProcessor $linkProcessor */
+      $linkProcessor = \Drupal::service(LinkProcessor::class);
+
+      // Ensure that the redirect links point to correct URLs.
+      $build['#markup'] = $linkProcessor->processLinks($build['#markup'], 'inbound');
+      $build['#markup'] = $linkProcessor->processLinks(
+        $build['#markup'],
+        'outbound',
+        \Drupal::languageManager()->getCurrentLanguage()
+      );
+      $build['#cache']['max-age'] = 0;
+    }
+
+    return $build;
+  }
+
+}

package/drupal/silverback_gutenberg/tests/graphql/.graphqlrc.json

@@ -0,0 +1,5 @@
+{
+  "name": "GraphQL Directives - Gutenberg",
+  "schemaPath": "./schema.graphqls",
+  "includes": ["./directives.graphqls"]
+}

package/drupal/silverback_gutenberg/tests/graphql/queries/editor.gql

@@ -0,0 +1,30 @@
+fragment Page on Page {
+  title
+  content {
+    __typename
+    ... on Text {
+      content
+    }
+    ... on Figure {
+      caption
+      image {
+        alt
+      }
+      imageAlt
+    }
+    ... on Columns {
+      columns {
+        __typename
+      }
+    }
+  }
+}
+
+query {
+  en {
+    ...Page
+  }
+  de {
+    ...Page
+  }
+}

package/drupal/silverback_gutenberg/tests/graphql/schema.graphqls

@@ -0,0 +1,37 @@
+type Query {
+  en: Page @loadEntity(type: "node", id: "1")
+  de: Page @loadEntity(type: "node", id: "1") @entityTranslation(lang: "de")
+}
+
+type Page {
+  title: String! @property(path: "title.value")
+  content: [Blocks]!
+    @resolveEditorBlocks(
+      path: "body.value"
+      aggregated: ["core/paragraph", "core/list"]
+    )
+}
+
+union Blocks @resolveEditorBlockType = Text | Figure | Columns
+
+union ColumnBlocks @resolveEditorBlockType = Text | Figure
+
+type Text @type(id: "core/paragraph") {
+  content: String @resolveEditorBlockMarkup
+}
+
+type Figure @type(id: "custom/figure") {
+  caption: String @resolveEditorBlockAttribute(key: "caption")
+  image: Image @resolveEditorBlockMedia
+  imageAlt: String
+    @resolveEditorBlockMedia
+    @property(path: "field_media_image.alt")
+}
+
+type Image {
+  alt: String @property(path: "field_media_image.alt")
+}
+
+type Columns @type(id: "custom/columns") {
+  columns: [ColumnBlocks]! @resolveEditorBlockChildren
+}

package/drupal/silverback_gutenberg/tests/modules/silverback_gutenberg_test_validator/silverback_gutenberg_test_validator.info.yml

@@ -0,0 +1,9 @@
+name: Silverback Gutenberg Test Validator
+type: module
+description:
+  'Support module for Silverback Gutenberg validators plugin system testing.'
+package: 'Silverback Testing'
+core_version_requirement: ^8 || ^9 || ^10 || ^11
+
+dependencies:
+  - silverback_gutenberg:silverback_gutenberg

package/drupal/silverback_gutenberg/tests/modules/silverback_gutenberg_test_validator/src/Plugin/Validation/GutenbergValidator/ColumnValidator.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Drupal\silverback_gutenberg_test_validator\Plugin\Validation\GutenbergValidator;
+
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergCardinalityValidatorInterface;
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergCardinalityValidatorTrait;
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorBase;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+
+/**
+ * Validate test plugin for the ANY cardinality.
+ *
+ * @GutenbergValidator(
+ *   id="column_validator",
+ *   label = @Translation("Column validator"),
+ * )
+ */
+class ColumnValidator extends GutenbergValidatorBase {
+
+  use GutenbergCardinalityValidatorTrait;
+  use StringTranslationTrait;
+
+  /**
+   * {@inheritDoc}
+   */
+  public function applies(array $block): bool {
+    return $block['blockName'] === 'core/column';
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validateContent(array $block = []): array {
+    $expectedChildren = [
+      'validationType' => GutenbergCardinalityValidatorInterface::CARDINALITY_ANY,
+      'min' => 1,
+      'max' => 2,
+    ];
+    return $this->validateCardinality($block, $expectedChildren);
+  }
+
+}

package/drupal/silverback_gutenberg/tests/modules/silverback_gutenberg_test_validator/src/Plugin/Validation/GutenbergValidator/GroupValidator.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Drupal\silverback_gutenberg_test_validator\Plugin\Validation\GutenbergValidator;
+
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergCardinalityValidatorTrait;
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorBase;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+
+/**
+ * Validate test plugin for multiple types of inner blocks.
+ *
+ * @GutenbergValidator(
+ *   id="group_validator",
+ *   label = @Translation("Group validator"),
+ * )
+ */
+class GroupValidator extends GutenbergValidatorBase {
+
+  use GutenbergCardinalityValidatorTrait;
+  use StringTranslationTrait;
+
+  /**
+   * {@inheritDoc}
+   */
+  public function applies(array $block): bool {
+    return $block['blockName'] === 'core/group';
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validateContent(array $block = []): array {
+    $expectedChildren = [
+      [
+        'blockName' => 'core/paragraph',
+        'blockLabel' => $this->t('Paragraph'),
+        'min' => 1,
+        'max' => 2,
+      ],
+      [
+        'blockName' => 'core/list',
+        'blockLabel' => $this->t('List'),
+        'min' => 1,
+        'max' => 1,
+      ],
+    ];
+    return $this->validateCardinality($block, $expectedChildren);
+  }
+
+}

package/drupal/silverback_gutenberg/tests/modules/silverback_gutenberg_test_validator/src/Plugin/Validation/GutenbergValidator/LinkValidator.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Drupal\silverback_gutenberg_test_validator\Plugin\Validation\GutenbergValidator;
+
+use Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorBase;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+
+/**
+ * Validate test plugin to check if a linkUrl and linkLabel attribute exists.
+ *
+ * @GutenbergValidator(
+ *   id="link_validator",
+ *   label = @Translation("Link URL"),
+ * )
+ */
+class LinkValidator extends GutenbergValidatorBase {
+
+  use StringTranslationTrait;
+
+  /**
+   * {@inheritDoc}
+   */
+  public function applies(array $block): bool {
+    return $block['blockName'] === 'custom/link';
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public function validatedFields($block = []): array {
+    return [
+      'linkUrl' => [
+        'field_label' => $this->t('Link URL'),
+        'rules' => ['required']
+      ],
+      'linkLabel' => [
+        'field_label' => $this->t('Link Label'),
+        'rules' => ['required']
+      ],
+    ];
+  }
+
+}

package/drupal/silverback_gutenberg/tests/src/Kernel/BlockValidationRuleTest.php

@@ -0,0 +1,194 @@
+<?php
+
+namespace Drupal\Tests\silverback_gutenberg\Kernel;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\node\Entity\Node;
+use Drupal\silverback_gutenberg\Plugin\Validation\Constraint\Gutenberg;
+use Drupal\silverback_gutenberg\Plugin\Validation\Constraint\GutenbergValidator;
+use Drupal\Tests\node\Traits\ContentTypeCreationTrait;
+use Drupal\Tests\silverback_gutenberg\Traits\SampleAssetTrait;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+class BlockValidationRuleTest extends KernelTestBase {
+
+  use ContentTypeCreationTrait;
+  use SampleAssetTrait;
+
+  const FIELD_NAME = 'field_test';
+
+  protected static $modules = [
+    'system',
+    'path_alias',
+    'field',
+    'node',
+    'user',
+    'text',
+    'silverback_gutenberg',
+    'silverback_gutenberg_test_validator',
+  ];
+
+  /**
+   * @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleManager
+   */
+  protected $validatorRulePluginManager;
+
+  /**
+   * @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorManager
+   */
+  protected $validatorPluginManager;
+
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->installSchema('system', 'sequences');
+    $this->installEntitySchema('node');
+    $this->installEntitySchema('user');
+    $this->installConfig('node');
+    $this->createContentType([
+      'type' => 'page',
+      'name' => 'Basic page'
+    ]);
+
+    $this->validatorRulePluginManager = \Drupal::service('plugin.manager.gutenberg_validator_rule');
+    $this->validatorPluginManager = \Drupal::service('plugin.manager.gutenberg_validator');
+  }
+
+  public function testEmailValidatorRule(): void {
+    /** @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleInterface $emailValidator */
+    $emailValidator = $this->validatorRulePluginManager->createInstance('email');
+    $this->assertTrue($emailValidator->validate('test@example', self::FIELD_NAME));
+    $this->assertTrue($emailValidator->validate('test@example.com', self::FIELD_NAME));
+    $this->assertEquals($emailValidator->validate('test@', self::FIELD_NAME), '<em class="placeholder">' . self::FIELD_NAME . '</em> is not valid.');
+  }
+
+  public function testRequiredValidatorRule(): void {
+    $requiredMessage = '<em class="placeholder">' . self::FIELD_NAME . '</em> field is required.';
+    /** @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorRuleInterface $requiredValidator */
+    $requiredValidator = $this->validatorRulePluginManager->createInstance('required');
+    $this->assertTrue($requiredValidator->validate('banana', self::FIELD_NAME));
+    $this->assertEquals($requiredValidator->validate(NULL, self::FIELD_NAME), $requiredMessage);
+    $this->assertEquals($requiredValidator->validate('', self::FIELD_NAME), $requiredMessage);
+    $this->assertEquals($requiredValidator->validate('_none', self::FIELD_NAME), $requiredMessage);
+  }
+
+  /**
+   * Limit test to content validator only.
+   *
+   * More specific cardinality tests are covered by BlocksValidatorCardinalityTest.
+   *
+   * @return void
+   */
+  public function testContentValidator(): void {
+    // Validates any blocks.
+    /** @var \Drupal\silverback_gutenberg\GutenbergValidation\GutenbergValidatorInterface $columnValidator */
+    $columnValidator = $this->validatorPluginManager->createInstance('column_validator');
+    $columnBlock = [
+      'blockName' => 'core/column',
+      'innerBlocks' => [
+        [
+          'blockName' => 'core/paragraph',
+        ],
+        [
+          'blockName' => 'core/list',
+        ],
+      ],
+    ];
+    $this->assertEquals($columnValidator->validateContent($columnBlock), ['is_valid' => TRUE, 'message' => '']);
+
+    // Validates multiple specific blocks.
+    $groupValidator = $this->validatorPluginManager->createInstance('group_validator');
+    $groupBlock = [
+      'blockName' => 'core/group',
+      'innerBlocks' => [
+        [
+          'blockName' => 'core/paragraph',
+        ],
+        [
+          'blockName' => 'core/paragraph',
+        ],
+        [
+          'blockName' => 'core/list',
+        ],
+      ],
+    ];
+    $this->assertEquals($groupValidator->validateContent($groupBlock), ['is_valid' => TRUE, 'message' => '']);
+  }
+
+  /**
+   * @dataProvider providerTestFieldValidator
+   */
+  public function testFieldValidator(string $body, array $expected_violations): void {
+    $context = $this->prophesize(ExecutionContextInterface::class);
+    $constraintValidator = new GutenbergValidator($this->validatorPluginManager, $this->validatorRulePluginManager);
+    $constraintValidator->initialize($context->reveal());
+
+    $node = Node::create([
+      'type' => 'page',
+      'title' => 'Test',
+      'body' => $body,
+    ]);
+    $node->save();
+    $constraintValidator->validate($node->get('body'), new Gutenberg());
+    $violations = $this->getViolations($constraintValidator);
+    $this->assertEquals($violations, $expected_violations);
+  }
+
+  /**
+   * Data provider for ::testFieldValidator().
+   */
+  public function providerTestFieldValidator() {
+    return [
+      [
+        'body' => '<!-- wp:custom/link {"linkLabel":"test","linkUrl":"https://example.com"} /-->',
+        'violations' => [],
+      ],
+      [
+        'body' => '<!-- wp:custom/link {"linkLabel":"test","linkUrl":""} /-->',
+        'violations' => [
+          [
+            'attribute' => 'linkUrl',
+            'blockName' => 'custom/link',
+            'rule' => 'required',
+            'message' => '<span class="block-validation-error" data-block-instance="1" data-block-type="custom/link">Link: <em class="placeholder">Link URL</em> field is required.</span>',
+          ],
+        ]
+      ],
+      [
+        'body' => '<!-- wp:custom/link {"linkLabel":"","linkUrl":"https://example.com"} /-->',
+        'violations' => [
+          [
+            'attribute' => 'linkLabel',
+            'blockName' => 'custom/link',
+            'rule' => 'required',
+            'message' => '<span class="block-validation-error" data-block-instance="1" data-block-type="custom/link">Link: <em class="placeholder">Link Label</em> field is required.</span>'
+          ],
+        ]
+      ],
+      [
+        'body' => '<!-- wp:custom/link {"linkLabel":"","linkUrl":""} /-->',
+        'violations' => [
+          [
+            'attribute' => 'linkUrl',
+            'blockName' => 'custom/link',
+            'rule' => 'required',
+            'message' => '<span class="block-validation-error" data-block-instance="1" data-block-type="custom/link">Link: <em class="placeholder">Link URL</em> field is required.</span>',
+          ],
+          [
+            'attribute' => 'linkLabel',
+            'blockName' => 'custom/link',
+            'rule' => 'required',
+            'message' => '<span class="block-validation-error" data-block-instance="1" data-block-type="custom/link">Link: <em class="placeholder">Link Label</em> field is required.</span>'
+          ],
+        ]
+      ]
+    ];
+  }
+
+  private function getViolations(GutenbergValidator $validator) {
+    $reflection = new \ReflectionClass($validator);
+    $property = $reflection->getProperty('violations');
+    return $property->getValue($validator);
+  }
+
+}