Add "skip when" expressions support

Author: Kirill Nesmeyanov

composer.json

@@ -31,6 +31,7 @@
         "phpunit/phpunit": "^10.5|^11.0",
         "rector/rector": "^1.1",
         "symfony/cache": "^5.4|^6.0|^7.0",
+        "symfony/expression-language": "^5.4|^6.0|^7.0",
         "symfony/property-access": "^5.4|^6.0|^7.0",
         "symfony/stopwatch": "^5.4|^6.0|^7.0",
         "symfony/var-dumper": "^5.4|^6.0|^7.0",

src/Mapping/Driver/AttributeDriver.php

@@ -4,8 +4,11 @@
 
 namespace TypeLang\Mapper\Mapping\Driver;
 
+use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
 use TypeLang\Mapper\Exception\Definition\PropertyTypeNotFoundException;
 use TypeLang\Mapper\Exception\Definition\TypeNotFoundException;
+use TypeLang\Mapper\Exception\Environment\ComposerPackageRequiredException;
 use TypeLang\Mapper\Mapping\MapName;
 use TypeLang\Mapper\Mapping\MapType;
 use TypeLang\Mapper\Mapping\Metadata\ClassMetadata;
@@ -16,6 +19,49 @@
 
 final class AttributeDriver extends LoadableDriver
 {
+    public function __construct(
+        DriverInterface $delegate = new NullDriver(),
+        private ?ExpressionLanguage $expression = null,
+    ) {
+        parent::__construct($delegate);
+    }
+
+    /**
+     * @throws ComposerPackageRequiredException
+     */
+    private function getExpressionLanguage(): ExpressionLanguage
+    {
+        return $this->expression ??= $this->createDefaultExpressionLanguage();
+    }
+
+    /**
+     * @throws ComposerPackageRequiredException
+     */
+    private function createDefaultExpressionLanguage(): ExpressionLanguage
+    {
+        if (!\class_exists(ExpressionLanguage::class)) {
+            throw ComposerPackageRequiredException::becausePackageNotInstalled(
+                package: 'symfony/expression-language',
+                purpose: 'expressions support',
+            );
+        }
+
+        return new ExpressionLanguage();
+    }
+
+    /**
+     * @param non-empty-string $expression
+     * @param list<non-empty-string> $names
+     *
+     * @throws ComposerPackageRequiredException
+     */
+    private function createExpression(string $expression, array $names): ParsedExpression
+    {
+        $parser = $this->getExpressionLanguage();
+
+        return $parser->parse($expression, $names);
+    }
+
     #[\Override]
     protected function load(
         \ReflectionClass $reflection,
@@ -55,9 +101,11 @@ protected function load(
             $attribute = $this->findPropertyAttribute($property, SkipWhen::class);
 
             if ($attribute !== null) {
-                $type = $this->createType($attribute->type, $property, $types, $parser);
+                $expression = $this->createExpression($attribute->expr, [
+                    'this',
+                ]);
 
-                $metadata->setSkipCondition($type);
+                $metadata->setSkipCondition($expression);
             }
         }
     }

src/Mapping/Metadata/PropertyMetadata.php

@@ -4,6 +4,7 @@
 
 namespace TypeLang\Mapper\Mapping\Metadata;
 
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
 use TypeLang\Mapper\Runtime\Context;
 use TypeLang\Parser\Node\Stmt\NamedTypeNode;
 use TypeLang\Parser\Node\Stmt\Shape\NamedFieldNode;
@@ -20,7 +21,7 @@ final class PropertyMetadata extends Metadata
 
     private bool $hasDefaultValue = false;
 
-    private ?TypeMetadata $skipWhen = null;
+    private ?ParsedExpression $skipWhen = null;
 
     /**
      * @param non-empty-string $export
@@ -157,9 +158,9 @@ public function findTypeInfo(): ?TypeMetadata
     /**
      * @api
      */
-    public function setSkipCondition(TypeMetadata $type): void
+    public function setSkipCondition(ParsedExpression $expression): void
     {
-        $this->skipWhen = $type;
+        $this->skipWhen = $expression;
     }
 
     /**
@@ -179,14 +180,14 @@ public function hasSkipCondition(): bool
     }
 
     /**
-     * Note: The prefix "find" is used to indicate that the {@see TypeMetadata}
+     * Note: The prefix "find" is used to indicate that the {@see ParsedExpression}
      *       definition may be optional and method may return {@see null}.
      *       The prefix "get" is used when the value is forced to be obtained
      *       and should throw an exception if the type definition is missing.
      *
      * @api
      */
-    public function findSkipCondition(): ?TypeMetadata
+    public function findSkipCondition(): ?ParsedExpression
     {
         return $this->skipWhen;
     }

src/Mapping/SkipWhen.php

@@ -11,6 +11,6 @@ public function __construct(
         /**
          * @var non-empty-string
          */
-        public readonly string $type,
+        public readonly string $expr,
     ) {}
 }

src/Type/ObjectType/ObjectTypeNormalizer.php

@@ -96,11 +96,11 @@ protected function normalizeObject(object $object, Context $context): array
 
             // Skip the property when condition is matched
             $skip = $meta->findSkipCondition();
+
             if ($skip !== null) {
-                $condition = $skip->getType();
+                $nodes = $skip->getNodes();
 
-                // Skip when condition is matched
-                if ($condition->match($fieldValue, $entrance)) {
+                if ((bool) $nodes->evaluate([], ['this' => $object])) {
                     continue;
                 }
             }