Support explicit container configuration for arguments with defaults

Author: clue

docs/best-practices/controllers.md

@@ -188,7 +188,8 @@ covers most common use cases:
 * Class names need to be loadable through the autoloader. See
   [composer autoloading](#composer-autoloading) above.
 * Each class may or may not have a constructor.
-* If the constructor has an optional argument, it will be omitted.
+* If the constructor has an optional argument, it will be omitted unless an
+  explicit [container configuration](#container-configuration) is used.
 * If the constructor has a nullable argument, it will be given a `null` value
   unless an explicit [container configuration](#container-configuration) is used.
 * If the constructor references another class, it will load this class next.
@@ -307,6 +308,25 @@ manual configuration like this:
         'hostname' => fn(): string => gethostname()
     ]);
 
+    // …
+    ```
+
+=== "Default values"
+
+    ```php title="public/index.php"
+    <?php
+
+    require __DIR__ . '/../vendor/autoload.php';
+
+    $container = new FrameworkX\Container([
+        Acme\Todo\UserController::class => function (bool $debug = false) {
+            // example UserController class uses $debug, apply default if not set
+            return new Acme\Todo\UserController($debug);
+        },
+        'debug' => true
+    ]);
+
+
     // …
     ```
 

src/Container.php

@@ -197,13 +197,6 @@ private function loadFunctionParams(\ReflectionFunctionAbstract $function, int $
     {
         $params = [];
         foreach ($function->getParameters() as $parameter) {
-            assert($parameter instanceof \ReflectionParameter);
-
-            // stop building parameters when encountering first optional parameter
-            if ($parameter->isOptional()) {
-                break;
-            }
-
             $params[] = $this->loadParameter($parameter, $depth, $allowVariables);
         }
 
@@ -219,13 +212,18 @@ private function loadParameter(\ReflectionParameter $parameter, int $depth, bool
         // ensure parameter is typed
         $type = $parameter->getType();
         if ($type === null) {
+            if ($parameter->isDefaultValueAvailable()) {
+                return $parameter->getDefaultValue();
+            }
             throw new \BadMethodCallException(self::parameterError($parameter) . ' has no type');
         }
 
+        $hasDefault = $parameter->isDefaultValueAvailable() || $parameter->allowsNull();
+
         // abort for union types (PHP 8.0+) and intersection types (PHP 8.1+)
         if ($type instanceof \ReflectionUnionType || $type instanceof \ReflectionIntersectionType) { // @codeCoverageIgnoreStart
-            if ($type->allowsNull()) {
-                return null;
+            if ($hasDefault) {
+                return $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null;
             }
             throw new \BadMethodCallException(self::parameterError($parameter) . ' expects unsupported type ' . $type);
         } // @codeCoverageIgnoreEnd
@@ -238,8 +236,8 @@ private function loadParameter(\ReflectionParameter $parameter, int $depth, bool
         }
 
         // use null for nullable arguments if not already loaded above
-        if ($type->allowsNull() && !isset($this->container[$type->getName()])) {
-            return null;
+        if ($hasDefault && !isset($this->container[$type->getName()])) {
+            return $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null;
         }
 
         // abort if required container variable is not defined

tests/ContainerTest.php

@@ -156,6 +156,124 @@ public function __invoke(ServerRequestInterface $request)
         $this->assertEquals('null', (string) $response->getBody());
     }
 
+    public function testCallableReturnsCallableForClassWithNullDefaultViaAutowiringWillDefaultToNullValue()
+    {
+        $request = new ServerRequest('GET', 'http://example.com/');
+
+        $controller = new class(null) {
+            private $data = false;
+
+            public function __construct(\stdClass $data = null)
+            {
+                $this->data = $data;
+            }
+
+            public function __invoke(ServerRequestInterface $request)
+            {
+                return new Response(200, [], json_encode($this->data));
+            }
+        };
+
+        $container = new Container([]);
+
+        $callable = $container->callable(get_class($controller));
+        $this->assertInstanceOf(\Closure::class, $callable);
+
+        $response = $callable($request);
+        $this->assertInstanceOf(ResponseInterface::class, $response);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('null', (string) $response->getBody());
+    }
+
+    public function testCallableReturnsCallableForClassWithNullDefaultViaContainerConfiguration()
+    {
+        $request = new ServerRequest('GET', 'http://example.com/');
+
+        $controller = new class(null) {
+            private $data = false;
+
+            public function __construct(\stdClass $data = null)
+            {
+                $this->data = $data;
+            }
+
+            public function __invoke(ServerRequestInterface $request)
+            {
+                return new Response(200, [], json_encode($this->data));
+            }
+        };
+
+        $container = new Container([
+            \stdClass::class => (object) []
+        ]);
+
+        $callable = $container->callable(get_class($controller));
+        $this->assertInstanceOf(\Closure::class, $callable);
+
+        $response = $callable($request);
+        $this->assertInstanceOf(ResponseInterface::class, $response);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{}', (string) $response->getBody());
+    }
+
+    /**
+     * @requires PHP 8
+     */
+    public function testCallableReturnsCallableForUnionWithIntDefaultValueViaAutowiringWillDefaultToIntValue()
+    {
+        $request = new ServerRequest('GET', 'http://example.com/');
+
+        $controller = new class(null) {
+            private $data = false;
+
+            #[PHP8] public function __construct(string|int|null $data = 42) { $this->data = $data; }
+
+            public function __invoke(ServerRequestInterface $request)
+            {
+                return new Response(200, [], json_encode($this->data));
+            }
+        };
+
+        $container = new Container([]);
+
+        $callable = $container->callable(get_class($controller));
+        $this->assertInstanceOf(\Closure::class, $callable);
+
+        $response = $callable($request);
+        $this->assertInstanceOf(ResponseInterface::class, $response);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('42', (string) $response->getBody());
+    }
+
+    public function testCallableReturnsCallableForUndefaultWithStringDefaultViaAutowiringWillDefaultToStringValue()
+    {
+        $request = new ServerRequest('GET', 'http://example.com/');
+
+        $controller = new class(null) {
+            private $data = false;
+
+            public function __construct($data = 'empty')
+            {
+                $this->data = $data;
+            }
+
+            public function __invoke(ServerRequestInterface $request)
+            {
+                return new Response(200, [], json_encode($this->data));
+            }
+        };
+
+        $container = new Container([]);
+
+        $callable = $container->callable(get_class($controller));
+        $this->assertInstanceOf(\Closure::class, $callable);
+
+        $response = $callable($request);
+        $this->assertInstanceOf(ResponseInterface::class, $response);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('"empty"', (string) $response->getBody());
+    }
+
     public function testCallableReturnsCallableForClassNameViaAutowiringWithFactoryFunctionForDependency()
     {
         $request = new ServerRequest('GET', 'http://example.com/');
@@ -469,6 +587,40 @@ public function __invoke()
         $this->assertEquals('{"user":{},"data":null}', (string) $response->getBody());
     }
 
+    public function testCallableReturnsCallableForClassNameWithDependencyMappedWithFactoryThatRequiresContainerVariablesWithDefaultValues()
+    {
+        $request = new ServerRequest('GET', 'http://example.com/');
+
+        $controller = new class(new Response()) {
+            private $response;
+
+            public function __construct(ResponseInterface $response)
+            {
+                $this->response = $response;
+            }
+
+            public function __invoke()
+            {
+                return $this->response;
+            }
+        };
+
+        $container = new Container([
+            ResponseInterface::class => function (string $name = 'Alice', int $age = 0) {
+                return new Response(200, [], json_encode(['name' => $name, 'age' => $age]));
+            },
+            'age' => 42
+        ]);
+
+        $callable = $container->callable(get_class($controller));
+        $this->assertInstanceOf(\Closure::class, $callable);
+
+        $response = $callable($request);
+        $this->assertInstanceOf(ResponseInterface::class, $response);
+        $this->assertEquals(200, $response->getStatusCode());
+        $this->assertEquals('{"name":"Alice","age":42}', (string) $response->getBody());
+    }
+
     public function testCallableReturnsCallableForClassNameWithDependencyMappedWithFactoryThatRequiresScalarVariables()
     {
         $request = new ServerRequest('GET', 'http://example.com/');