Replaced opis/closure due to it now seeming inactive and causing warning with PHP 8.4

Author: philipobenito

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [6.2.0] 2024-11
+
+### Changed
+- Replaced opis/closure with laravel/serializable-closure and implemented throughout the handler process rather than a blanket serialisation of the router.
+
 ## [6.1.1] 2024-11
 
 ### Fixed

composer.json

@@ -22,13 +22,13 @@
     ],
     "require": {
         "php": "^8.1",
+        "laravel/serializable-closure": "^2.0.0",
         "nikic/fast-route": "^1.3",
         "psr/container": "^2.0",
         "psr/http-factory": "^1.0",
         "psr/http-message": "^2.0",
         "psr/http-server-handler": "^1.0.1",
         "psr/http-server-middleware": "^1.0.1",
-        "opis/closure": "^3.6.3",
         "psr/simple-cache": "^3.0"
     },
     "require-dev": {

docs/_data/releases.yml

@@ -22,7 +22,7 @@
     name: League\Route 6.x
     type: Current
     requires: PHP >= 8.1.0
-    release: 6.1.1 - 2024-11
+    release: 6.2.0 - 2024-11
     support: Ongoing
     url: /6.x/
     menu:

src/Cache/Router.php

@@ -11,50 +11,61 @@
 namespace League\Route\Cache;
 
 use InvalidArgumentException;
+use Laravel\SerializableClosure\SerializableClosure;
 use League\Route\Router as MainRouter;
 use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
 use Psr\SimpleCache\CacheInterface;
 
-use function Opis\Closure\{serialize as s, unserialize as u};
-
 class Router
 {
     /**
      * @var callable
      */
     protected $builder;
 
-    /**
-     * @var integer
-     */
-    protected $ttl;
+    protected int $ttl;
 
     public function __construct(
         callable $builder,
         protected CacheInterface $cache,
         protected bool $cacheEnabled = true,
         protected string $cacheKey = 'league/route/cache'
     ) {
+        if (true === $this->cacheEnabled && $builder instanceof \Closure) {
+            $builder = new SerializableClosure($builder);
+        }
+
         $this->builder = $builder;
     }
 
+    /**
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     */
     public function dispatch(ServerRequestInterface $request): ResponseInterface
     {
         $router = $this->buildRouter($request);
         return $router->dispatch($request);
     }
 
+    /**
+     * @throws \Psr\SimpleCache\InvalidArgumentException
+     */
     protected function buildRouter(ServerRequestInterface $request): MainRouter
     {
         if (true === $this->cacheEnabled && $cache = $this->cache->get($this->cacheKey)) {
-            $router = u($cache, ['allowed_classes' => true]);
+            $router = unserialize($cache, ['allowed_classes' => true]);
 
             if ($router instanceof MainRouter) {
                 return $router;
             }
         }
 
         $builder = $this->builder;
+
+        if ($builder instanceof SerializableClosure) {
+            $builder = $builder->getClosure();
+        }
+
         $router = $builder(new MainRouter());
 
         if (false === $this->cacheEnabled) {
@@ -63,7 +74,7 @@ protected function buildRouter(ServerRequestInterface $request): MainRouter
 
         if ($router instanceof MainRouter) {
             $router->prepareRoutes($request);
-            $this->cache->set($this->cacheKey, s($router));
+            $this->cache->set($this->cacheKey, serialize($router));
             return $router;
         }
 

src/Route.php

@@ -4,6 +4,7 @@
 
 namespace League\Route;
 
+use Laravel\SerializableClosure\SerializableClosure;
 use League\Route\Middleware\{MiddlewareAwareInterface, MiddlewareAwareTrait};
 use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\NotFoundExceptionInterface;
@@ -36,13 +37,21 @@ public function __construct(
         protected ?RouteGroup $group = null,
         protected array $vars = []
     ) {
+        if ($handler instanceof \Closure) {
+            $handler = new SerializableClosure($handler);
+        }
+
         $this->handler = ($handler instanceof RequestHandlerInterface) ? [$handler, 'handle'] : $handler;
     }
 
     public function getCallable(?ContainerInterface $container = null): callable
     {
         $callable = $this->handler;
 
+        if ($callable instanceof SerializableClosure) {
+            $callable = $callable->getClosure();
+        }
+
         if (is_string($callable) && str_contains($callable, '::')) {
             $callable = explode('::', $callable);
         }