4.x - Add an advanced callable resolver

Slim/AdvancedCallableResolver.php

@@ -0,0 +1,157 @@
+<?php
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim/blob/4.x/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim;
+
+use Closure;
+use Psr\Container\ContainerInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use RuntimeException;
+use Slim\Interfaces\AdvancedCallableResolverInterface;
+
+final class AdvancedCallableResolver implements AdvancedCallableResolverInterface
+{
+    /**
+     * @var ContainerInterface|null
+     */
+    private $container;
+
+    /**
+     * @param ContainerInterface|null $container
+     */
+    public function __construct(?ContainerInterface $container = null)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolve($toResolve): callable
+    {
+        $resolved = $toResolve;
+
+        if (!is_callable($toResolve) && is_string($toResolve)) {
+            $resolved = $this->resolveInstanceAndMethod($toResolve);
+            if ($resolved[1] === null) {
+                $resolved[1] = '__invoke';
+            }
+        }
+
+        return $this->checkResolvedAndBindContainerIfClosure($resolved, $toResolve);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolveRoute($toResolve): callable
+    {
+        $resolved = $toResolve;
+
+        if (!is_callable($toResolve) && is_string($toResolve)) {
+            [$instance, $method] = $this->resolveInstanceAndMethod($toResolve);
+
+            // For a class that implements RequestHandlerInterface, we will call handle()
+            // if no method has been specified explicitly
+            if ($instance instanceof RequestHandlerInterface && $method === null) {
+                $method = 'handle';
+            }
+
+            $resolved = [$instance, $method ?? '__invoke'];
+        }
+
+        if ($resolved instanceof RequestHandlerInterface) {
+            $resolved = [$resolved, 'handle'];
+        }
+
+        return $this->checkResolvedAndBindContainerIfClosure($resolved, $toResolve);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolveMiddleware($toResolve): callable
+    {
+        $resolved = $toResolve;
+
+        if (!is_callable($toResolve) && is_string($toResolve)) {
+            [$instance, $method] = $this->resolveInstanceAndMethod($toResolve);
+
+            // For a class that implements MiddlewareInterface, we will call process()
+            // if no method has been specified explicitly
+            if ($instance instanceof MiddlewareInterface && $method === null) {
+                $method = 'process';
+            }
+
+            $resolved = [$instance, $method ?? '__invoke'];
+        }
+
+        if ($resolved instanceof MiddlewareInterface) {
+            $resolved = [$resolved, 'process'];
+        }
+
+        return $this->checkResolvedAndBindContainerIfClosure($resolved, $toResolve);
+    }
+
+    /**
+     * Resolves the given param and if successful returns an instance as well
+     * as a method name.
+     *
+     * @param string $toResolve
+     *
+     * @return array [Instance, Method Name]
+     */
+    private function resolveInstanceAndMethod(string $toResolve): array
+    {
+        $class = $toResolve;
+        $instance = null;
+        $method = null;
+
+        // Check for Slim callable as `class:method`
+        if (preg_match(CallableResolver::$callablePattern, $toResolve, $matches)) {
+            $class = $matches[1];
+            $method = $matches[2];
+        }
+
+        if ($this->container && $this->container->has($class)) {
+            $instance = $this->container->get($class);
+        } else {
+            if (!class_exists($class)) {
+                throw new RuntimeException(sprintf('Callable %s does not exist', $class));
+            }
+            $instance = new $class($this->container);
+        }
+
+        return [$instance, $method];
+    }
+
+    /**
+     * @param mixed                        $resolved
+     * @param string|object|array|callable $toResolve
+     *
+     * @return callable
+     */
+    private function checkResolvedAndBindContainerIfClosure($resolved, $toResolve): callable
+    {
+        if (!is_callable($resolved)) {
+            throw new RuntimeException(sprintf(
+                '%s is not resolvable',
+                is_callable($toResolve) || is_object($toResolve) || is_array($toResolve) ?
+                    json_encode($toResolve) : $toResolve
+            ));
+        }
+
+        if ($this->container && $resolved instanceof Closure) {
+            $resolved = $resolved->bindTo($this->container);
+        }
+
+        return $resolved;
+    }
+}

Slim/App.php

@@ -60,15 +60,15 @@ public function __construct(
     ) {
         parent::__construct(
             $responseFactory,
-            $callableResolver ?? new CallableResolver($container),
+            $callableResolver ?? new AdvancedCallableResolver($container),
             $container,
             $routeCollector
         );
 
         $this->routeResolver = $routeResolver ?? new RouteResolver($this->routeCollector);
         $routeRunner = new RouteRunner($this->routeResolver, $this->routeCollector->getRouteParser());
 
-        $this->middlewareDispatcher = new MiddlewareDispatcher($routeRunner, $container);
+        $this->middlewareDispatcher = new MiddlewareDispatcher($routeRunner, $container, $this->callableResolver);
     }
 
     /**

Slim/Interfaces/AdvancedCallableResolverInterface.php

@@ -0,0 +1,31 @@
+<?php
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim/blob/4.x/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Interfaces;
+
+interface AdvancedCallableResolverInterface extends CallableResolverInterface
+{
+    /**
+     * Resolve $toResolve into a callable
+     *
+     * @param string|callable $toResolve
+     *
+     * @return callable
+     */
+    public function resolveRoute($toResolve): callable;
+
+    /**
+     * Resolve $toResolve into a callable
+     *
+     * @param string|callable $toResolve
+     *
+     * @return callable
+     */
+    public function resolveMiddleware($toResolve): callable;
+}

Slim/MiddlewareDispatcher.php

@@ -16,6 +16,8 @@
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use RuntimeException;
+use Slim\Interfaces\AdvancedCallableResolverInterface;
+use Slim\Interfaces\CallableResolverInterface;
 
 class MiddlewareDispatcher implements RequestHandlerInterface
 {
@@ -32,15 +34,23 @@ class MiddlewareDispatcher implements RequestHandlerInterface
     protected $container;
 
     /**
-     * @param RequestHandlerInterface $kernel
-     * @param ContainerInterface|null $container
+     * @var CallableResolverInterface|null
+     */
+    protected $callableResolver;
+
+    /**
+     * @param RequestHandlerInterface        $kernel
+     * @param ContainerInterface|null        $container
+     * @param CallableResolverInterface|null $callableResolver
      */
     public function __construct(
         RequestHandlerInterface $kernel,
-        ?ContainerInterface $container = null
+        ?ContainerInterface $container = null,
+        ?CallableResolverInterface $callableResolver = null
     ) {
         $this->seedMiddlewareStack($kernel);
         $this->container = $container;
+        $this->callableResolver = $callableResolver;
     }
 
     /**
@@ -141,53 +151,66 @@ public function handle(ServerRequestInterface $request): ResponseInterface
     public function addDeferred(string $middleware): self
     {
         $next = $this->tip;
-        $this->tip = new class($middleware, $next, $this->container) implements RequestHandlerInterface
+        $this->tip = new class(
+            $middleware,
+            $next,
+            $this->container,
+            $this->callableResolver
+        ) implements RequestHandlerInterface
         {
             private $middleware;
             private $next;
             private $container;
+            private $callableResolver;
 
             public function __construct(
                 string $middleware,
                 RequestHandlerInterface $next,
-                ?ContainerInterface $container = null
+                ?ContainerInterface $container = null,
+                ?CallableResolverInterface $callableResolver = null
             ) {
                 $this->middleware = $middleware;
                 $this->next = $next;
                 $this->container = $container;
+                $this->callableResolver = $callableResolver;
             }
 
             public function handle(ServerRequestInterface $request): ResponseInterface
             {
-                $resolved = $this->middleware;
-                $instance = null;
-                $method = null;
-
-                // Check for Slim callable as `class:method`
-                if (preg_match(CallableResolver::$callablePattern, $resolved, $matches)) {
-                    $resolved = $matches[1];
-                    $method = $matches[2];
-                }
-
-                if ($this->container && $this->container->has($resolved)) {
-                    $instance = $this->container->get($resolved);
-                    if ($instance instanceof MiddlewareInterface) {
-                        return $instance->process($request, $this->next);
+                $callable = null;
+                if ($this->callableResolver === null) {
+                    $resolved = $this->middleware;
+                    $instance = null;
+                    $method = null;
+
+                    // Check for Slim callable as `class:method`
+                    if (preg_match(CallableResolver::$callablePattern, $resolved, $matches)) {
+                        $resolved = $matches[1];
+                        $method = $matches[2];
                     }
-                } elseif (!function_exists($resolved)) {
-                    if (!class_exists($resolved)) {
-                        throw new RuntimeException(sprintf('Middleware %s does not exist', $resolved));
+
+                    if ($this->container && $this->container->has($resolved)) {
+                        $instance = $this->container->get($resolved);
+                        if ($instance instanceof MiddlewareInterface) {
+                            return $instance->process($request, $this->next);
+                        }
+                    } elseif (!function_exists($resolved)) {
+                        if (!class_exists($resolved)) {
+                            throw new RuntimeException(sprintf('Middleware %s does not exist', $resolved));
+                        }
+                        $instance = new $resolved($this->container);
                     }
-                    $instance = new $resolved($this->container);
-                }
 
-                if ($instance && $instance instanceof MiddlewareInterface) {
-                    return $instance->process($request, $this->next);
-                }
+                    if ($instance && $instance instanceof MiddlewareInterface) {
+                        return $instance->process($request, $this->next);
+                    }
 
-                $callable = $instance ?? $resolved;
-                if ($instance && $method) {
-                    $callable = [$instance, $method];
+                    $callable = $instance ?? $resolved;
+                    if ($instance && $method) {
+                        $callable = [$instance, $method];
+                    }
+                } elseif ($this->callableResolver instanceof AdvancedCallableResolverInterface) {
+                    $callable = $this->callableResolver->resolveMiddleware($this->middleware);
                 }
 
                 if (!is_callable($callable)) {

Slim/Routing/Route.php

@@ -17,6 +17,7 @@
 use Psr\Http\Server\RequestHandlerInterface;
 use Slim\Handlers\Strategies\RequestHandler;
 use Slim\Handlers\Strategies\RequestResponse;
+use Slim\Interfaces\AdvancedCallableResolverInterface;
 use Slim\Interfaces\CallableResolverInterface;
 use Slim\Interfaces\InvocationStrategyInterface;
 use Slim\Interfaces\RequestHandlerInvocationStrategyInterface;
@@ -360,7 +361,11 @@ protected function appendGroupMiddlewareToRoute(): void
      */
     public function handle(ServerRequestInterface $request): ResponseInterface
     {
-        $callable = $this->callableResolver->resolve($this->callable);
+        if ($this->callableResolver instanceof AdvancedCallableResolverInterface) {
+            $callable = $this->callableResolver->resolveRoute($this->callable);
+        } else {
+            $callable = $this->callableResolver->resolve($this->callable);
+        }
         $strategy = $this->invocationStrategy;
 
         if (is_array($callable)

Slim/Routing/RouteGroup.php

@@ -10,6 +10,7 @@
 namespace Slim\Routing;
 
 use Psr\Http\Server\MiddlewareInterface;
+use Slim\Interfaces\AdvancedCallableResolverInterface;
 use Slim\Interfaces\CallableResolverInterface;
 use Slim\Interfaces\RouteCollectorProxyInterface;
 use Slim\Interfaces\RouteGroupInterface;
@@ -65,7 +66,11 @@ public function __construct(
      */
     public function collectRoutes(): RouteGroupInterface
     {
-        $callable = $this->callableResolver->resolve($this->callable);
+        if ($this->callableResolver instanceof AdvancedCallableResolverInterface) {
+            $callable = $this->callableResolver->resolveRoute($this->callable);
+        } else {
+            $callable = $this->callableResolver->resolve($this->callable);
+        }
         $callable($this->routeCollectorProxy);
         return $this;
     }