Added relative internal link validation option for link fields

config/schema/stanford_fields.schema.yml

@@ -33,3 +33,11 @@ field.widget.settings.localist_url:
  select_distinct:
  type: boolean
  label: 'Select Distinct'
+
+field.field.*.third_party.stanford_fields:
+ type: config_entity
+ label: "Stanford Fields third party settings"
+ mapping:
+ force_relative:
+ type: boolean
+ label: "Force relative internal links"

src/Plugin/Validation/Constraint/RelativeLinkFieldItemConstraint.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Drupal\stanford_fields\Plugin\Validation\Constraint;
+
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Symfony\Component\Validator\Constraint as SymfonyConstraint;
+use Drupal\Core\Validation\Attribute\Constraint;
+
+/**
+ * Checks that the submitted value is a unique integer.
+ */
+#[Constraint(
+ id: 'relative_internal_link',
+ label: new TranslatableMarkup('Relative Internal Link', [], ['context' => 'Validation'])
+)]
+class RelativeLinkFieldItemConstraint extends SymfonyConstraint {
+
+ public $absoluteLink = 'Please use relative links that start with "/" for paths on this site.';
+
+}

src/Plugin/Validation/Constraint/RelativeLinkFieldItemConstraintValidator.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Drupal\stanford_fields\Plugin\Validation\Constraint;
+
+use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+
+/**
+ * Validates the Menu link item constraint.
+ */
+class RelativeLinkFieldItemConstraintValidator extends ConstraintValidator implements ContainerInjectionInterface {
+
+ /**
+ * Current request.
+ *
+ * @var \Drupal\path_alias\AliasManagerInterface
+ */
+ protected $request;
+
+ /**
+ * {@inheritDoc}
+ */
+ public static function create(ContainerInterface $container) {
+ return new static($container->get('request_stack'));
+ }
+
+ /**
+ * Validation constructor.
+ *
+ * @param \Symfony\Component\HttpFoundation\RequestStack $request_stack
+ * Current request stack.
+ */
+ public function __construct(RequestStack $request_stack) {
+ $this->request = $request_stack->getCurrentRequest();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function validate($value, Constraint $constraint) {
+ /** @var \Drupal\Core\Field\FieldItemListInterface $value */
+ $link_uri = $value->get(0)?->get('uri')?->getString();
+ if ($link_uri && str_contains($link_uri, $this->request->getSchemeAndHttpHost())) {
+ $this->context->addViolation($constraint->absoluteLink);
+ }
+ }
+
+}

stanford_fields.module

@@ -5,7 +5,61 @@
  * stanford_fields.module
  */
 
+use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\Core\Form\FormStateInterface;
+use Drupal\field\FieldConfigInterface;
+
+/**
+ * Implements hook_form_BASE_FORM_ID_alter().
+ */
+function stanford_fields_form_field_config_edit_form_alter(&$form, FormStateInterface $form_state, $form_id) {
+ /** @var \Drupal\field\FieldConfigInterface $field_config */
+ $field_config = $form_state->get('field_config');
+ if ($field_config->getType() == 'link') {
+ $form['settings']['force_relative'] = [
+ '#type' => 'checkbox',
+ '#title' => t('Force relative internal links'),
+ '#default_value' => $field_config->getThirdPartySetting('stanford_fields', 'force_relative'),
+ '#states' => [
+ 'invisible' => [
+ ':input[name="settings[link_type]"]' => ['value' => '16'],
+ ],
+ ],
+ ];
+ $form['#entity_builders'][] = 'stanford_fields_form_field_config_entity_builder';
+ }
+}
+
+/**
+ * Field config form submission to save the third party settings.
+ *
+ * @param string $entity_type
+ * Entity type ID.
+ * @param \Drupal\field\FieldConfigInterface $entity
+ * Submitted entity object.
+ * @param array $form
+ * Submitted form render array.
+ * @param \Drupal\Core\Form\FormStateInterface $form_state
+ * Submitted form state.
+ */
+function stanford_fields_form_field_config_entity_builder(string $entity_type, FieldConfigInterface $entity, array &$form, FormStateInterface $form_state) {
+ if ($form_state->getValue(['settings', 'force_relative'])) {
+ $entity->setThirdPartySetting('stanford_fields', 'force_relative', TRUE);
+ return;
+ }
+ $entity->unsetThirdPartySetting('stanford_fields', 'force_relative');
+}
+
+/**
+ * Implements hook_entity_bundle_field_info_alter().
+ */
+function stanford_fields_entity_bundle_field_info_alter(&$fields, EntityTypeInterface $entity_type, $bundle) {
+ foreach ($fields as $field) {
+ if ($field->getType() == 'link' && $field->getThirdPartySetting('stanford_fields', 'force_relative')) {
+ $field->addConstraint('relative_internal_link', []);
+ }
+ }
+}
 
 /**
  * Implements hook_form_FORM_ID_alter().

tests/src/Unit/Plugin/Validation/Constraint/LinkFieldItemConstraintValidatorTest.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Drupal\Tests\stanford_fields\Unit\Plugin\Validation\Constraint;
+
+use Drupal\Core\DependencyInjection\Container;
+use Drupal\Core\Validation\ExecutionContext;
+use Drupal\Core\Validation\TranslatorInterface;
+use Drupal\stanford_fields\Plugin\Validation\Constraint\RelativeLinkFieldItemConstraint;
+use Drupal\stanford_fields\Plugin\Validation\Constraint\RelativeLinkFieldItemConstraintValidator;
+use Drupal\Tests\UnitTestCase;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Drupal\Core\Field\FieldItemListInterface;
+use Drupal\Core\Field\FieldItemInterface;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+
+/**
+ * @coversDefaultClass \Drupal\stanford_fields\Plugin\Validation\Constraint\RelativeLinkFieldItemConstraintValidator
+ */
+class LinkFieldItemConstraintValidatorTest extends UnitTestCase {
+
+ /**
+ * Data provider for validator.
+ *
+ * @return array[]
+ */
+ public function dataProvider() {
+ return [
+ ['http://localhost', 'http://localhost/foo/bar', TRUE],
+ ['http://localhost', '/foo/bar', FALSE],
+ ['http://localhost', 'http://hostlocal/foo/bar', FALSE],
+ ];
+ }
+
+ /**
+ * Tests the validate method.
+ *
+ * @dataProvider dataProvider
+ */
+ public function testValidation($currentDomain, $linkUrl, $shouldHaveViolations) {
+ // Create mocks for the services and dependencies.
+ $request_stack = $this->createMock(RequestStack::class);
+
+ $field_item_list = $this->createMock(FieldItemListInterface::class);
+ $field_item = $this->createMock(FieldItemInterface::class);
+ $request = $this->createMock(Request::class);
+
+ // Configure the request mock to return a specific scheme and host.
+ $request->method('getSchemeAndHttpHost')->willReturn($currentDomain);
+ $request_stack->method('getCurrentRequest')->willReturn($request);
+
+ // Configure the field item list mock to return a field item with a specific URI.
+ $field_item->method('get')->willReturnSelf();
+ $field_item->method('getString')->willReturn($linkUrl);
+ $field_item_list->method('get')->with(0)->willReturn($field_item);
+
+ $container = new Container();
+ $container->set('request_stack', $request_stack);
+
+ $validator = $this->createMock(ValidatorInterface::class);
+ $translator = $this->createMock(TranslatorInterface::class);
+ $translator->method('trans')->willReturnCallback(fn($message) => $message);
+ $context = new ExecutionContext($validator, NULL, $translator);
+
+ // Instantiate the validator and set the context.
+ $validator = TestRelativeLinkValidator::create($container);
+ $validator->initialize($context);
+
+ $constraint = new RelativeLinkFieldItemConstraint();
+ $context->setConstraint($constraint);
+
+ // Call the validate method.
+ $validator->validate($field_item_list, $constraint);
+ if ($shouldHaveViolations) {
+ $this->assertTrue($validator->hasViolation());
+ }
+ else {
+ $this->assertFalse($validator->hasViolation());
+ }
+ }
+
+}
+
+class TestRelativeLinkValidator extends RelativeLinkFieldItemConstraintValidator {
+
+ public function hasViolation() {
+ return count($this->context->getViolations()) > 0;
+ }
+
+}