Remove Param Sync

composer.json

@@ -22,10 +22,12 @@
     },
     "require": {
         "php": ">=8.5",
+        "psr/container": "^2.0",
         "psr/http-factory": "^1.0",
         "psr/http-message": "^2.0",
         "psr/http-server-handler": "^1.0",
-        "psr/http-server-middleware": "^1.0"
+        "psr/http-server-middleware": "^1.0",
+        "respect/parameter": "^1.0"
     },
     "require-dev": {
         "nyholm/psr7": "^1.8",

docs/README.md

@@ -220,7 +220,7 @@ $r3->get('/download/*', function(string $file, ResponseInterface $response) {
 ```
 
   1. Parameters are matched by type, not position. Mix them freely with route parameters.
-  2. This works with callback routes and class controller methods alike.
+  2. This works with callback routes, class controller methods, and routine callbacks alike.
 
 ## PSR-15 Integration
 
@@ -291,11 +291,9 @@ $r3->get('/documents/*', function($documentId) {
 ```
 
   1. This will match the route only if the callback on *when* is matched.
-  2. The `$documentId` param must have the same name in the action and the
-     condition (but does not need to appear in the same order).
+  2. Route parameters are passed positionally, matching the order of the `/*` segments.
   3. You can specify more than one parameter per condition callback.
   4. You can chain conditions: `when($cb1)->when($cb2)->when($etc)`
-  5. Conditions will also sync with parameters on bound classes and instance methods.
 
 This makes it possible to validate parameters using any custom routine and
 not just data types such as `int` or `string`.
@@ -324,7 +322,7 @@ $r3->get('/artists/*/albums/*', function($artistName, $albumName) {
 ```
 
   1. This will execute the callback defined with *by* before the route action.
-  2. Parameters are synced by name, not by order, like with `when`.
+  2. Route parameters are passed positionally, matching the order of the `/*` segments.
   3. You can specify more than one parameter per proxy callback.
   4. You can chain proxies: `by($cb1)->by($cb2)->by($etc)`
   5. A `return false` from a proxy will stop the execution of any following proxies
@@ -350,7 +348,6 @@ $r3->post('/artists/*/albums/*', function($artistName, $albumName) {
   1. `by` proxies will be executed before the route action, `through` proxies
      will be executed after.
   2. You are free to use them separately or in tandem.
-  3. `through` can also receive parameters by name.
 
 When processing something after the route has run, it's often desirable to process
 its output as well. This can be achieved with a nested closure:
@@ -386,23 +383,6 @@ A simple way of applying routines to every route on the router is:
 $r3->always('By', $logRoutine);
 ```
 
-You can use the param sync to take advantage of this:
-```php
-$r3->always('When', function($user=null) {
-    if ($user) {
-        return strlen($user) > 3;
-    }
-});
-
-$r3->any('/products', function () { /***/ });
-$r3->any('/users/*', function ($user) { /***/ });
-$r3->any('/users/*/products', function ($user) { /***/ });
-$r3->any('/listeners/*', function ($user) { /***/ });
-```
-
-Since there are three routes with the `$user` parameter, `when` will
-verify them all automatically by name.
-
 ## File Extensions
 
 Use the `fileExtension` routine to map URL extensions to response transformations:
@@ -556,7 +536,6 @@ appended to the route. Custom routines have the option of several different inte
 which can be implemented:
 
   * `IgnorableFileExtension` - Instructs the router to ignore the file extension in requests.
-  * `ParamSynced` - Syncs parameters with the route function/method.
   * `ProxyableBy` - Instructs the router to run method `by()` before the route.
   * `ProxyableThrough` - Instructs the router to run method `through()` after the route.
   * `ProxyableWhen` - Instructs the router to run method `when()` to validate the route match.

src/DispatchContext.php

@@ -4,26 +4,25 @@
 
 namespace Respect\Rest;
 
+use Psr\Container\ContainerInterface;
 use Psr\Http\Message\ResponseFactoryInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\StreamFactoryInterface;
-use ReflectionFunctionAbstract;
-use ReflectionParameter;
+use Respect\Parameter\Resolver;
 use Respect\Rest\Routes\AbstractRoute;
-use Respect\Rest\Routines\ParamSynced;
-use Respect\Rest\Routines\Routinable;
 use Throwable;
 
 use function is_a;
 use function rawurldecode;
 use function rtrim;
 use function set_error_handler;
+use function sprintf;
 use function strtolower;
 use function strtoupper;
 
 /** Internal routing context wrapping a PSR-7 server request */
-final class DispatchContext
+final class DispatchContext implements ContainerInterface
 {
     /** @var array<int, mixed> */
     public array $params = [];
@@ -53,6 +52,8 @@ final class DispatchContext
     /** @var array<int, AbstractRoute> */
     private array $sideRoutes = [];
 
+    private Resolver|null $resolver = null;
+
     public function __construct(
         public ServerRequestInterface $request,
         public ResponseFactoryInterface&StreamFactoryInterface $factory,
@@ -180,33 +181,6 @@ public function response(): ResponseInterface|null
         }
     }
 
-    /** @param array<int, mixed> $params */
-    public function routineCall(
-        string $type,
-        string $method,
-        Routinable $routine,
-        array &$params,
-        AbstractRoute $route,
-    ): mixed {
-        $reflection = $route->getTargetReflection($method);
-
-        $callbackParameters = [];
-
-        if (!$routine instanceof ParamSynced) {
-            $callbackParameters = $params;
-        } elseif ($reflection !== null) {
-            foreach ($routine->getParameters() as $parameter) {
-                $callbackParameters[] = $this->extractRouteParam(
-                    $reflection,
-                    $parameter,
-                    $params,
-                );
-            }
-        }
-
-        return $routine->{$type}($this, $callbackParameters);
-    }
-
     public function forward(AbstractRoute $route): ResponseInterface|null
     {
         $this->route = $route;
@@ -230,6 +204,30 @@ public function setResponder(Responder $responder): void
         $this->responder = $responder;
     }
 
+    public function resolver(): Resolver
+    {
+        return $this->resolver ??= new Resolver($this);
+    }
+
+    public function has(string $id): bool
+    {
+        return is_a($id, ServerRequestInterface::class, true)
+            || is_a($id, ResponseInterface::class, true);
+    }
+
+    public function get(string $id): mixed
+    {
+        if (is_a($id, ServerRequestInterface::class, true)) {
+            return $this->request;
+        }
+
+        if (is_a($id, ResponseInterface::class, true)) {
+            return $this->ensureResponseDraft();
+        }
+
+        throw new NotFoundException(sprintf('No entry found for "%s"', $id));
+    }
+
     /** @return callable|null The previous error handler, or null */
     protected function prepareForErrorForwards(AbstractRoute $route): callable|null
     {
@@ -310,28 +308,6 @@ protected function forwardToStatusRoute(ResponseInterface $preparedResponse): Re
         return null;
     }
 
-    /** @param array<int, mixed> $params */
-    protected function extractRouteParam(
-        ReflectionFunctionAbstract $callback,
-        ReflectionParameter $routeParam,
-        array &$params,
-    ): mixed {
-        foreach ($callback->getParameters() as $callbackParamReflection) {
-            if (
-                $callbackParamReflection->getName() === $routeParam->getName()
-                && isset($params[$callbackParamReflection->getPosition()])
-            ) {
-                return $params[$callbackParamReflection->getPosition()];
-            }
-        }
-
-        if ($routeParam->isDefaultValueAvailable()) {
-            return $routeParam->getDefaultValue();
-        }
-
-        return null;
-    }
-
     protected function finalizeResponse(mixed $response): ResponseInterface
     {
         return $this->responder()->finalize(

src/NotFoundException.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Respect\Rest;
+
+use Exception;
+use Psr\Container\NotFoundExceptionInterface;
+
+final class NotFoundException extends Exception implements NotFoundExceptionInterface
+{
+}

src/Routes/AbstractRoute.php

@@ -7,7 +7,6 @@
 use ReflectionClass;
 use ReflectionFunctionAbstract;
 use Respect\Rest\DispatchContext;
-use Respect\Rest\ResolvesCallbackArguments;
 use Respect\Rest\Routines\IgnorableFileExtension;
 use Respect\Rest\Routines\Routinable;
 use Respect\Rest\Routines\Unique;
@@ -55,8 +54,6 @@
 // phpcs:ignore SlevomatCodingStandard.Classes.SuperfluousAbstractClassNaming.SuperfluousPrefix
 abstract class AbstractRoute
 {
-    use ResolvesCallbackArguments;
-
     public const string CATCHALL_IDENTIFIER = '/**';
 
     public const array CORE_METHODS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'];
@@ -135,11 +132,6 @@ public function getTargetMethod(string $method): string
         return $method;
     }
 
-    public function getTargetReflection(string $method): ReflectionFunctionAbstract|null
-    {
-        return $this->getReflection($this->getTargetMethod($method));
-    }
-
     /** @param array<int, mixed> $params */
     public function dispatchTarget(string $method, array &$params, DispatchContext $context): mixed
     {

src/Routes/Callback.php

@@ -4,14 +4,11 @@
 
 namespace Respect\Rest\Routes;
 
-use Closure;
-use ReflectionFunction;
 use ReflectionFunctionAbstract;
-use ReflectionMethod;
+use Respect\Parameter\Resolver;
 use Respect\Rest\DispatchContext;
 
 use function array_merge;
-use function is_array;
 
 class Callback extends AbstractRoute
 {
@@ -31,11 +28,7 @@ public function __construct(
 
     public function getCallbackReflection(): ReflectionFunctionAbstract
     {
-        if (is_array($this->callback)) {
-            return new ReflectionMethod($this->callback[0], $this->callback[1]);
-        }
-
-        return new ReflectionFunction(Closure::fromCallable($this->callback));
+        return Resolver::reflectCallable($this->callback);
     }
 
     public function getReflection(string $method): ReflectionFunctionAbstract
@@ -51,7 +44,7 @@ public function getReflection(string $method): ReflectionFunctionAbstract
     public function runTarget(string $method, array &$params, DispatchContext $context): mixed
     {
         $reflection = $this->getReflection($method);
-        $args = $this->resolveCallbackArguments($reflection, array_merge($params, $this->arguments), $context);
+        $args = $context->resolver()->resolve($reflection, array_merge($params, $this->arguments));
 
         return ($this->callback)(...$args);
     }

src/Routes/ControllerRoute.php

@@ -97,7 +97,7 @@ protected function invokeTarget(object $target, string $method, array &$params,
     {
         $reflection = $this->getReflection($method);
         if ($reflection !== null) {
-            $args = $this->resolveCallbackArguments($reflection, $params, $context);
+            $args = $context->resolver()->resolve($reflection, $params);
 
             return $target->$method(...$args);
         }