Use closure in PurgeOn::if

CHANGELOG.md

@@ -13,6 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   in https://github.com/sofascore/purgatory-bundle/pull/112
 - Ability to pass a static method callable as a `DynamicValues` provider by @HypeMC
   in https://github.com/sofascore/purgatory-bundle/pull/137
+- Ability to use a closure as the `PurgeOn` `if` condition on PHP 8.5+ by @Brajk19
+  in https://github.com/sofascore/purgatory-bundle/pull/116
 
 ### Changed
 

composer.json

@@ -47,6 +47,7 @@
     },
     "require-dev": {
         "doctrine/common": "^3.2",
+        "opis/closure": "^4.3",
         "phpunit/phpunit": "^12.5",
         "symfony/cache": "^6.4 || ^7.4 || ^8.0",
         "symfony/doctrine-messenger": "^6.4 || ^7.4 || ^8.0",

docs/README.md

@@ -378,6 +378,33 @@ In this example, the purge will only occur if the post has more than 3,000 upvot
 
 You can also add [custom Expression Language functions](custom-expression-language-functions.md).
 
+### Adding Conditional Logic with Closures
+
+Starting with [PHP 8.5](https://www.php.net/releases/8.5/en.php), closures can be used in attributes, so the same
+condition can be written in plain PHP instead of an expression. The closure receives the entity as its only argument:
+
+```php
+#[Route('/post/{id<\d+>}', name: 'post_details', methods: 'GET')]
+#[PurgeOn(Post::class, if: static function (Post $post): bool {
+    return $post->upvotes > 3000;
+})]
+public function detailsAction(Post $post)
+{
+}
+```
+
+This feature requires the [`opis/closure`](https://github.com/opis/closure) package:
+
+```sh
+composer require opis/closure
+```
+
+The closure must:
+
+- have exactly one parameter, typed with the subscribed entity class or one of its parents,
+- declare a non-nullable `bool` return type.
+
+
 ### Using Purge on Actions with Multiple Routes
 
 By default, the attribute generates URLs for all routes associated with the action. You can limit this to one or more

phpstan-baseline.neon

@@ -13,13 +13,13 @@ parameters:
 			path: src/Attribute/RouteParamValue/EnumValues.php
 
 		-
-			message: '#^Parameter \#1 \$configuration of class Sofascore\\PurgatoryBundle\\Cache\\Configuration\\Configuration constructor expects array\<non\-empty\-string, list\<array\{routeName\: string, routeParams\?\: array\<string, array\{type\: string, values\: list\<mixed\>, optional\?\: true\}\>, if\?\: string, actions\?\: non\-empty\-list\<Sofascore\\PurgatoryBundle\\Listener\\Enum\\Action\>\}\>\>, mixed given\.$#'
+			message: '#^Parameter \#1 \$configuration of class Sofascore\\PurgatoryBundle\\Cache\\Configuration\\Configuration constructor expects array\<non\-empty\-string, list\<array\{routeName\: string, routeParams\?\: array\<string, array\{type\: string, values\: list\<mixed\>, optional\?\: true\}\>, if\?\: string, closureIf\?\: true, actions\?\: non\-empty\-list\<Sofascore\\PurgatoryBundle\\Listener\\Enum\\Action\>\}\>\>, mixed given\.$#'
 			identifier: argument.type
 			count: 1
 			path: src/Cache/Configuration/CachedConfigurationLoader.php
 
 		-
-			message: '#^Method Sofascore\\PurgatoryBundle\\Cache\\Configuration\\Subscriptions\:\:getIterator\(\) should return Traversable\<int, array\{routeName\: string, routeParams\?\: array\<string, array\{type\: string, values\: list\<mixed\>, optional\?\: true\}\>, if\?\: string, actions\?\: non\-empty\-list\<Sofascore\\PurgatoryBundle\\Listener\\Enum\\Action\>\}\> but returns ArrayIterator\<int, array\{routeName\: string, routeParams\?\: array\<string, array\{type\: string, values\: list\<mixed\>, optional\?\: bool\}\>, if\?\: string, actions\?\: non\-empty\-list\<Sofascore\\PurgatoryBundle\\Listener\\Enum\\Action\>\}\>\.$#'
+			message: '#^Method Sofascore\\PurgatoryBundle\\Cache\\Configuration\\Subscriptions\:\:getIterator\(\) should return Traversable\<int, array\{routeName\: string, routeParams\?\: array\<string, array\{type\: string, values\: list\<mixed\>, optional\?\: true\}\>, if\?\: string, closureIf\?\: true, actions\?\: non\-empty\-list\<Sofascore\\PurgatoryBundle\\Listener\\Enum\\Action\>\}\> but returns ArrayIterator\<int, array\{routeName\: string, routeParams\?\: array\<string, array\{type\: string, values\: list\<mixed\>, optional\?\: bool\}\>, if\?\: string, closureIf\?\: bool, actions\?\: non\-empty\-list\<Sofascore\\PurgatoryBundle\\Listener\\Enum\\Action\>\}\>\.$#'
 			identifier: return.type
 			count: 1
 			path: src/Cache/Configuration/Subscriptions.php

src/Attribute/PurgeOn.php

@@ -18,7 +18,7 @@ final class PurgeOn
     public readonly ?TargetInterface $target;
     /** @var ?non-empty-array<string, ValuesInterface> */
     public readonly ?array $routeParams;
-    public readonly ?Expression $if;
+    public readonly \Closure|Expression|null $if;
     /** @var ?non-empty-list<string> */
     public readonly ?array $route;
     /** @var ?non-empty-list<Action> */
@@ -35,10 +35,14 @@ public function __construct(
         public readonly string $class,
         string|array|TargetInterface|null $target = null,
         ?array $routeParams = null,
-        string|Expression|null $if = null,
+        \Closure|string|Expression|null $if = null,
         string|array|null $route = null,
         string|array|Action|null $actions = null,
     ) {
+        if ($if instanceof \Closure && !\function_exists('Opis\Closure\serialize')) {
+            throw new LogicException('You cannot use a closure for the "if" attribute because the "opis/closure" package is not installed. Try running "composer require opis/closure".');
+        }
+
         $this->target = \is_array($target) || \is_string($target) ? new ForProperties($target) : $target;
         $this->routeParams = null !== $routeParams ? self::normalizeRouteParams($routeParams) : null;
         $this->if = \is_string($if) ? self::normalizeExpression($if) : $if;

src/Cache/Configuration/Configuration.php

@@ -13,6 +13,7 @@ final class Configuration implements \Countable
      *     routeName: string,
      *     routeParams?: array<string, array{type: string, values: list<mixed>, optional?: true}>,
      *     if?: string,
+     *     closureIf?: true,
      *     actions?: non-empty-list<Action>,
      * }>> $configuration
      */
@@ -57,6 +58,7 @@ public function count(): int
      *     routeName: string,
      *     routeParams?: array<string, array{type: string, values: list<mixed>, optional?: true}>,
      *     if?: string,
+     *     closureIf?: true,
      *     actions?: non-empty-list<Action>,
      * }>>
      */

src/Cache/Configuration/ConfigurationLoader.php

@@ -8,6 +8,8 @@
 use Sofascore\PurgatoryBundle\Cache\Subscription\PurgeSubscriptionProviderInterface;
 use Symfony\Component\Routing\Route;
 
+use function Opis\Closure\serialize;
+
 final class ConfigurationLoader implements ConfigurationLoaderInterface
 {
     public function __construct(
@@ -38,7 +40,12 @@ public function load(): Configuration
             }
 
             if (null !== $subscription->if) {
-                $config['if'] = (string) $subscription->if;
+                if ($subscription->if instanceof \Closure) {
+                    $config['if'] = serialize($subscription->if);
+                    $config['closureIf'] = true;
+                } else {
+                    $config['if'] = (string) $subscription->if;
+                }
             }
 
             if (null !== $subscription->actions) {

src/Cache/Configuration/Subscriptions.php

@@ -11,6 +11,7 @@
  *     routeName: string,
  *     routeParams?: array<string, array{type: string, values: list<mixed>, optional?: true}>,
  *     if?: string,
+ *     closureIf?: true,
  *     actions?: non-empty-list<Action>,
  * }>
  */
@@ -22,6 +23,7 @@ final class Subscriptions implements \IteratorAggregate, \Countable
      *     routeName: string,
      *     routeParams?: array<string, array{type: string, values: list<mixed>, optional?: true}>,
      *     if?: string,
+     *     closureIf?: true,
      *     actions?: non-empty-list<Action>,
      * }> $subscriptions
      */
@@ -54,6 +56,7 @@ public function key(): string
      *     routeName: string,
      *     routeParams?: array<string, array{type: string, values: list<mixed>, optional?: true}>,
      *     if?: string,
+     *     closureIf?: true,
      *     actions?: non-empty-list<Action>,
      * }>
      */

src/Cache/PropertyResolver/AssociationResolver.php

@@ -73,6 +73,11 @@ public function resolveSubscription(
         }
 
         if (null !== $if = $routeMetadata->purgeOn->if) {
+            if ($if instanceof \Closure) {
+                // TODO support closures
+                throw new \RuntimeException('Cannot create inverse subscription with closures');
+            }
+
             $if = $this->expressionTransformer->transform($if, $associationClass, $associationTarget, 'false');
         }
 

src/Cache/Subscription/PurgeSubscription.php

@@ -23,7 +23,7 @@ public function __construct(
         public readonly string $routeName,
         public readonly Route $route,
         public readonly ?array $actions,
-        public readonly ?Expression $if = null,
+        public readonly \Closure|Expression|null $if = null,
     ) {
     }
 }

src/Cache/Subscription/PurgeSubscriptionProvider.php

@@ -15,6 +15,7 @@
 use Sofascore\PurgatoryBundle\Cache\RouteMetadata\RouteMetadataProviderInterface;
 use Sofascore\PurgatoryBundle\Cache\TargetResolver\TargetResolverInterface;
 use Sofascore\PurgatoryBundle\Exception\EntityMetadataNotFoundException;
+use Sofascore\PurgatoryBundle\Exception\InvalidIfClosureException;
 use Sofascore\PurgatoryBundle\Exception\InvalidIfExpressionException;
 use Sofascore\PurgatoryBundle\Exception\MissingRequiredRouteParametersException;
 use Sofascore\PurgatoryBundle\Exception\TargetSubscriptionNotResolvableException;
@@ -59,7 +60,7 @@ private function provideFromMetadata(RouteMetadataProviderInterface $routeMetada
             $purgeOn = $routeMetadata->purgeOn;
 
             if (null !== $purgeOn->if) {
-                $this->validateExpression($purgeOn->if, $routeMetadata->routeName);
+                $this->validateIf($purgeOn->if, $routeMetadata->routeName, $purgeOn->class);
             }
 
             // if route parameters are not specified, they are same as path variables
@@ -146,6 +147,52 @@ private function validateRouteParams(array $routeParams, RouteMetadata $routeMet
         }
     }
 
+    private function validateIf(\Closure|Expression $expression, string $routeName, string $entity): void
+    {
+        if ($expression instanceof \Closure) {
+            $this->validateIfClosure($expression, $routeName, $entity);
+
+            return;
+        }
+
+        $this->validateExpression($expression, $routeName);
+    }
+
+    private function validateIfClosure(\Closure $expression, string $routeName, string $entity): void
+    {
+        $reflection = new \ReflectionFunction($expression);
+
+        if (null !== $reflection->getClosureThis()) {
+            throw new InvalidIfClosureException($routeName, 'Closure must be static');
+        }
+
+        if ([] !== $reflection->getClosureUsedVariables()) {
+            throw new InvalidIfClosureException($routeName, 'Closure must not capture variables');
+        }
+
+        $returnType = $reflection->getReturnType();
+
+        if (!$returnType instanceof \ReflectionNamedType
+            || $returnType->allowsNull()
+            || !\in_array($returnType->getName(), ['bool', 'true', 'false'])
+        ) {
+            throw new InvalidIfClosureException($routeName, 'Return type must be bool');
+        }
+
+        if (1 !== $reflection->getNumberOfParameters()) {
+            throw new InvalidIfClosureException($routeName, 'Closure must have exactly 1 parameter');
+        }
+
+        $parameterType = $reflection->getParameters()[0]->getType();
+
+        if (!$parameterType instanceof \ReflectionNamedType
+            || $parameterType->allowsNull()
+            || !is_a($entity, $parameterType->getName(), true)
+        ) {
+            throw new InvalidIfClosureException($routeName, "Parameter in closure must be of type $entity");
+        }
+    }
+
     private function validateExpression(Expression $expression, string $routeName): void
     {
         try {

src/Command/DebugCommand.php

@@ -6,6 +6,8 @@
 
 use Doctrine\Persistence\ManagerRegistry;
 use Doctrine\Persistence\Mapping\ClassMetadata;
+use Opis\Closure\Box;
+use Opis\Closure\ReflectionClosure;
 use Sofascore\PurgatoryBundle\Attribute\RouteParamValue\CompoundValues;
 use Sofascore\PurgatoryBundle\Cache\Configuration\Configuration;
 use Sofascore\PurgatoryBundle\Cache\Configuration\ConfigurationLoaderInterface;
@@ -18,6 +20,8 @@
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Style\SymfonyStyle;
 
+use function Opis\Closure\unserialize;
+
 #[AsCommand(
     name: 'purgatory:debug',
     description: 'Display purge subscription information for an entity or multiple entities',
@@ -249,6 +253,7 @@ private function findSubscriptionsForRoute(string $routeName): array
      *     routeName: string,
      *     routeParams?: array<string, array{type: string, values: list<mixed>, optional?: true}>,
      *     if?: string,
+     *     closureIf?: true,
      *     actions?: non-empty-list<Action>,
      * }>> $configuration
      */
@@ -260,14 +265,25 @@ private function display(SymfonyStyle $io, array $configuration): void
             $entity = explode('::', $key);
 
             foreach ($subscriptions as $subscription) {
+                if (isset($subscription['closureIf'], $subscription['if'])) {
+                    /** @var \Closure $closure */
+                    $closure = unserialize($subscription['if'], options: ['allowed_classes' => [Box::class]]);
+                    $r = new ReflectionClosure($closure);
+                    $closureBody = $r->info()->getIncludePHP(false);
+
+                    $if = rtrim(substr($closureBody, strpos($closureBody, 'return ') + \strlen('return ')), ';');
+                } else {
+                    $if = $subscription['if'] ?? 'NONE';
+                }
+
                 $io->table(
                     ['Option', 'Value'],
                     [
                         ['Entity', $entity[0]],
                         ['Property', $entity[1] ?? 'ANY'],
                         ['Route Name', $subscription['routeName']],
                         ['Route Params', isset($subscription['routeParams']) ? $this->formatRouteParams($subscription['routeParams']) : 'NONE'],
-                        ['Condition', $subscription['if'] ?? 'NONE'],
+                        ['Condition', $if],
                         ['Actions', isset($subscription['actions']) ? $this->formatActions($subscription['actions']) : 'ANY'],
                     ],
                 );

src/Exception/InvalidIfClosureException.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sofascore\PurgatoryBundle\Exception;
+
+final class InvalidIfClosureException extends InvalidArgumentException
+{
+    public function __construct(
+        public readonly string $routeName,
+        string $message,
+    ) {
+        parent::__construct("Invalid 'if' closure for route '$routeName': $message");
+    }
+}

src/RouteProvider/AbstractEntityRouteProvider.php

@@ -5,6 +5,7 @@
 namespace Sofascore\PurgatoryBundle\RouteProvider;
 
 use Doctrine\ORM\PersistentCollection;
+use Opis\Closure\Box;
 use Psr\Container\ContainerInterface;
 use Sofascore\PurgatoryBundle\Cache\Configuration\Configuration;
 use Sofascore\PurgatoryBundle\Cache\Configuration\ConfigurationLoaderInterface;
@@ -15,6 +16,8 @@
 use Sofascore\PurgatoryBundle\RouteParamValueResolver\ValuesResolverInterface;
 use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
 
+use function Opis\Closure\unserialize;
+
 /**
  * @internal
  *
@@ -31,6 +34,9 @@ abstract protected function getChangedProperties(object $entity, array $entityCh
 
     private ?Configuration $configuration = null;
 
+    /** @var array<string, \Closure> */
+    private array $unserializedClosures = [];
+
     public function __construct(
         private readonly ConfigurationLoaderInterface $configurationLoader,
         private readonly ?ExpressionLanguage $expressionLanguage,
@@ -74,9 +80,17 @@ private function processValidSubscriptions(Subscriptions $subscriptions, array $
             }
 
             if (isset($subscription['if'])) {
-                $result = $this->getExpressionLanguage()->evaluate($subscription['if'], ['obj' => $entity]);
-                if (!\is_bool($result)) {
-                    throw new InvalidIfExpressionResultException($subscription['routeName'], $subscription['if'], $result);
+                if (isset($subscription['closureIf'])) {
+                    $closure = $this->unserializedClosures[$subscription['if']] ??= $this->unserializeClosure($subscription['if']);
+
+                    /** @var bool $result */
+                    $result = $closure($entity);
+                } else {
+                    $result = $this->getExpressionLanguage()->evaluate($subscription['if'], ['obj' => $entity]);
+
+                    if (!\is_bool($result)) {
+                        throw new InvalidIfExpressionResultException($subscription['routeName'], $subscription['if'], $result);
+                    }
                 }
 
                 if (!$result) {
@@ -170,4 +184,12 @@ private function getExpressionLanguage(): ExpressionLanguage
         return $this->expressionLanguage
             ?? throw new LogicException('You cannot use expressions because the Symfony ExpressionLanguage component is not installed. Try running "composer require symfony/expression-language".');
     }
+
+    private function unserializeClosure(string $serializedClosure): \Closure
+    {
+        /** @var \Closure $closure */
+        $closure = unserialize($serializedClosure, options: ['allowed_classes' => [Box::class]]);
+
+        return $closure;
+    }
 }