[Validator] Deprecate constraint "ExpressionLanguageSyntax", use "ExpressionSyntax" instead

Author: mpiot

CHANGELOG.md

@@ -5,6 +5,7 @@ CHANGELOG
 ---
 
  * Deprecate `Constraint::$errorNames`, use `Constraint::ERROR_NAMES` instead
+ * Deprecate constraint `ExpressionLanguageSyntax`, use `ExpressionSyntax` instead
 
 6.0
 ---

Constraints/ExpressionLanguageSyntax.php

@@ -13,11 +13,15 @@
 
 use Symfony\Component\Validator\Constraint;
 
+trigger_deprecation('symfony/validator', '6.1', 'The "%s" constraint is deprecated since symfony 6.1, use "ExpressionSyntax" instead.', ExpressionLanguageSyntax::class);
+
 /**
  * @Annotation
  * @Target({"PROPERTY", "METHOD", "ANNOTATION"})
  *
  * @author Andrey Sevastianov <[email protected]>
+ *
+ * @deprecated since symfony 6.1, use ExpressionSyntax instead
  */
 #[\Attribute(\Attribute::TARGET_PROPERTY | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
 class ExpressionLanguageSyntax extends Constraint

Constraints/ExpressionLanguageSyntaxValidator.php

@@ -18,8 +18,12 @@
 use Symfony\Component\Validator\Exception\UnexpectedTypeException;
 use Symfony\Component\Validator\Exception\UnexpectedValueException;
 
+trigger_deprecation('symfony/validator', '6.1', 'The "%s" constraint is deprecated since symfony 6.1, use "ExpressionSyntaxValidator" instead.', ExpressionLanguageSyntaxValidator::class);
+
 /**
  * @author Andrey Sevastianov <[email protected]>
+ *
+ * @deprecated since symfony 6.1, use ExpressionSyntaxValidator instead
  */
 class ExpressionLanguageSyntaxValidator extends ConstraintValidator
 {

Constraints/ExpressionSyntax.php

@@ -0,0 +1,51 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Validator\Constraints;
+
+use Symfony\Component\Validator\Constraint;
+
+/**
+ * @Annotation
+ * @Target({"PROPERTY", "METHOD", "ANNOTATION"})
+ *
+ * @author Andrey Sevastianov <[email protected]>
+ */
+#[\Attribute(\Attribute::TARGET_PROPERTY | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
+class ExpressionSyntax extends Constraint
+{
+    public const EXPRESSION_SYNTAX_ERROR = 'e219aa22-8b11-48ec-81a0-fc07cdb0e13f';
+
+    protected const ERROR_NAMES = [
+        self::EXPRESSION_SYNTAX_ERROR => 'EXPRESSION_SYNTAX_ERROR',
+    ];
+
+    public $message = 'This value should be a valid expression.';
+    public $service;
+    public $allowedVariables;
+
+    public function __construct(array $options = null, string $message = null, string $service = null, array $allowedVariables = null, array $groups = null, mixed $payload = null)
+    {
+        parent::__construct($options, $groups, $payload);
+
+        $this->message = $message ?? $this->message;
+        $this->service = $service ?? $this->service;
+        $this->allowedVariables = $allowedVariables ?? $this->allowedVariables;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function validatedBy(): string
+    {
+        return $this->service ?? static::class.'Validator';
+    }
+}

Constraints/ExpressionSyntaxValidator.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Validator\Constraints;
+
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Symfony\Component\ExpressionLanguage\SyntaxError;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+use Symfony\Component\Validator\Exception\UnexpectedTypeException;
+use Symfony\Component\Validator\Exception\UnexpectedValueException;
+
+/**
+ * @author Andrey Sevastianov <[email protected]>
+ */
+class ExpressionSyntaxValidator extends ConstraintValidator
+{
+    private ?ExpressionLanguage $expressionLanguage;
+
+    public function __construct(ExpressionLanguage $expressionLanguage = null)
+    {
+        $this->expressionLanguage = $expressionLanguage;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function validate(mixed $expression, Constraint $constraint): void
+    {
+        if (!$constraint instanceof ExpressionSyntax) {
+            throw new UnexpectedTypeException($constraint, ExpressionSyntax::class);
+        }
+
+        if (null === $expression || '' === $expression) {
+            return;
+        }
+
+        if (!\is_string($expression)) {
+            throw new UnexpectedValueException($expression, 'string');
+        }
+
+        if (null === $this->expressionLanguage) {
+            $this->expressionLanguage = new ExpressionLanguage();
+        }
+
+        try {
+            $this->expressionLanguage->lint($expression, $constraint->allowedVariables);
+        } catch (SyntaxError $exception) {
+            $this->context->buildViolation($constraint->message)
+                ->setParameter('{{ syntax_error }}', $this->formatValue($exception->getMessage()))
+                ->setInvalidValue((string) $expression)
+                ->setCode(ExpressionSyntax::EXPRESSION_SYNTAX_ERROR)
+                ->addViolation();
+        }
+    }
+}

Tests/Constraints/ExpressionLanguageSyntaxTest.php

@@ -17,6 +17,9 @@
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 use Symfony\Component\Validator\Mapping\Loader\AnnotationLoader;
 
+/**
+ * @group legacy
+ */
 class ExpressionLanguageSyntaxTest extends TestCase
 {
     public function testValidatedByStandardValidator()

Tests/Constraints/ExpressionLanguageSyntaxValidatorTest.php

@@ -16,6 +16,9 @@
 use Symfony\Component\Validator\Constraints\ExpressionLanguageSyntaxValidator;
 use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
 
+/**
+ * @group legacy
+ */
 class ExpressionLanguageSyntaxValidatorTest extends ConstraintValidatorTestCase
 {
     protected function createValidator()

Tests/Constraints/ExpressionSyntaxTest.php

@@ -0,0 +1,79 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Validator\Tests\Constraints;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Validator\Constraints\ExpressionSyntax;
+use Symfony\Component\Validator\Constraints\ExpressionSyntaxValidator;
+use Symfony\Component\Validator\Mapping\ClassMetadata;
+use Symfony\Component\Validator\Mapping\Loader\AnnotationLoader;
+
+class ExpressionSyntaxTest extends TestCase
+{
+    public function testValidatedByStandardValidator()
+    {
+        $constraint = new ExpressionSyntax();
+
+        self::assertSame(ExpressionSyntaxValidator::class, $constraint->validatedBy());
+    }
+
+    /**
+     * @dataProvider provideServiceValidatedConstraints
+     */
+    public function testValidatedByService(ExpressionSyntax $constraint)
+    {
+        self::assertSame('my_service', $constraint->validatedBy());
+    }
+
+    public function provideServiceValidatedConstraints(): iterable
+    {
+        yield 'Doctrine style' => [new ExpressionSyntax(['service' => 'my_service'])];
+
+        yield 'named arguments' => [new ExpressionSyntax(service: 'my_service')];
+
+        $metadata = new ClassMetadata(ExpressionSyntaxDummy::class);
+        self::assertTrue((new AnnotationLoader())->loadClassMetadata($metadata));
+
+        yield 'attribute' => [$metadata->properties['b']->constraints[0]];
+    }
+
+    public function testAttributes()
+    {
+        $metadata = new ClassMetadata(ExpressionSyntaxDummy::class);
+        self::assertTrue((new AnnotationLoader())->loadClassMetadata($metadata));
+
+        [$aConstraint] = $metadata->properties['a']->getConstraints();
+        self::assertNull($aConstraint->service);
+        self::assertNull($aConstraint->allowedVariables);
+
+        [$bConstraint] = $metadata->properties['b']->getConstraints();
+        self::assertSame('my_service', $bConstraint->service);
+        self::assertSame('myMessage', $bConstraint->message);
+        self::assertSame(['Default', 'ExpressionSyntaxDummy'], $bConstraint->groups);
+
+        [$cConstraint] = $metadata->properties['c']->getConstraints();
+        self::assertSame(['foo', 'bar'], $cConstraint->allowedVariables);
+        self::assertSame(['my_group'], $cConstraint->groups);
+    }
+}
+
+class ExpressionSyntaxDummy
+{
+    #[ExpressionSyntax]
+    private $a;
+
+    #[ExpressionSyntax(service: 'my_service', message: 'myMessage')]
+    private $b;
+
+    #[ExpressionSyntax(allowedVariables: ['foo', 'bar'], groups: ['my_group'])]
+    private $c;
+}

Tests/Constraints/ExpressionSyntaxValidatorTest.php

@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Validator\Tests\Constraints;
+
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Symfony\Component\Validator\Constraints\ExpressionSyntax;
+use Symfony\Component\Validator\Constraints\ExpressionSyntaxValidator;
+use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
+
+class ExpressionSyntaxValidatorTest extends ConstraintValidatorTestCase
+{
+    protected function createValidator()
+    {
+        return new ExpressionSyntaxValidator(new ExpressionLanguage());
+    }
+
+    public function testNullIsValid()
+    {
+        $this->validator->validate(null, new ExpressionSyntax());
+
+        $this->assertNoViolation();
+    }
+
+    public function testEmptyStringIsValid()
+    {
+        $this->validator->validate('', new ExpressionSyntax());
+
+        $this->assertNoViolation();
+    }
+
+    public function testExpressionValid()
+    {
+        $this->validator->validate('1 + 1', new ExpressionSyntax([
+            'message' => 'myMessage',
+            'allowedVariables' => [],
+        ]));
+
+        $this->assertNoViolation();
+    }
+
+    public function testExpressionWithoutNames()
+    {
+        $this->validator->validate('1 + 1', new ExpressionSyntax([
+            'message' => 'myMessage',
+        ]));
+
+        $this->assertNoViolation();
+    }
+
+    public function testExpressionWithAllowedVariableName()
+    {
+        $this->validator->validate('a + 1', new ExpressionSyntax([
+            'message' => 'myMessage',
+            'allowedVariables' => ['a'],
+        ]));
+
+        $this->assertNoViolation();
+    }
+
+    public function testExpressionIsNotValid()
+    {
+        $this->validator->validate('a + 1', new ExpressionSyntax([
+            'message' => 'myMessage',
+            'allowedVariables' => [],
+        ]));
+
+        $this->buildViolation('myMessage')
+            ->setParameter('{{ syntax_error }}', '"Variable "a" is not valid around position 1 for expression `a + 1`."')
+            ->setInvalidValue('a + 1')
+            ->setCode(ExpressionSyntax::EXPRESSION_SYNTAX_ERROR)
+            ->assertRaised();
+    }
+}