Fix #25 Inject request attributes

Currently route placeholders are injected in controllers. This was wrongly called "request attribute" in the documentation.

This adds the ability to inject (actual) request attributes in controller parameters too.

Route placeholders take priority over request attributes.

Example:

```php
$app->add(function ($request, $response, $next) {
    $request = $request->withAttribute('name', 'Bob');
    return $next($request, $response);
});

$app->get('/', function ($name, ResponseInterface $response) {
    $response->getBody()->write('Hello ' . $name);
    return $response;
});
```

Will show `Hello Bob`.

Author: mnapoli

README.md

@@ -54,9 +54,10 @@ By default, Slim controllers have a strict signature: `$request, $response, $arg
 
 Controller parameters can be any of these things:
 
-- request or response injection (parameters must be named `$request` or `$response`)
-- request attribute injection
-- service injection (by type-hint)
+- the request or response (parameters must be named `$request` or `$response`)
+- route placeholders
+- request attributes
+- services (injected by type-hint)
 
 You can mix all these types of parameters together too. They will be matched by priority in the order of the list above.
 
@@ -72,7 +73,7 @@ $app->get('/', function (ResponseInterface $response, ServerRequestInterface $re
 
 As you can see, the order of the parameters doesn't matter. That allows to skip injecting the `$request` if it's not needed for example.
 
-#### Request attribute injection
+#### Route placeholder injection
 
 ```php
 $app->get('/hello/{name}', function ($name, ResponseInterface $response) {
@@ -83,6 +84,22 @@ $app->get('/hello/{name}', function ($name, ResponseInterface $response) {
 
 As you can see above, the route's URL contains a `name` placeholder. By simply adding a parameter **with the same name** to the controller, PHP-DI will directly inject it.
 
+#### Request attribute injection
+
+```php
+$app->add(function ($request, $response, $next) {
+    $request = $request->withAttribute('name', 'Bob');
+    return $next($request, $response);
+});
+
+$app->get('/', function ($name, ResponseInterface $response) {
+    $response->getBody()->write('Hello ' . $name);
+    return $response;
+});
+```
+
+As you can see above, a middleware sets a `name` attribute. By simply adding a parameter **with the same name** to the controller, PHP-DI will directly inject it.
+
 #### Service injection
 
 To inject services into your controllers, you can write them as classes. But if you want to write a micro-application using closures, you don't have to give up dependency injection either.

src/ControllerInvoker.php

@@ -44,6 +44,9 @@ public function __invoke(
         // Inject the route arguments by name
         $parameters += $routeArguments;
 
+        // Inject the attributes defined on the request
+        $parameters += $request->getAttributes();
+
         return $this->invoker->call($callable, $parameters);
     }
 }

tests/RoutingTest.php

@@ -30,7 +30,7 @@ public function injects_request_and_response()
     /**
      * @test
      */
-    public function injects_request_path_parameters()
+    public function injects_route_placeholder()
     {
         $app = new App;
         $app->get('/{name}', function ($name, $response) {
@@ -45,7 +45,7 @@ public function injects_request_path_parameters()
     /**
      * @test
      */
-    public function injects_optional_path_parameter()
+    public function injects_optional_route_placeholder()
     {
         $app = new App;
         $app->get('/[{name}]', function ($response, $name = null) {
@@ -60,7 +60,7 @@ public function injects_optional_path_parameter()
     /**
      * @test
      */
-    public function injects_default_value_in_optional_path_parameter()
+    public function injects_default_value_in_optional_route_placeholder()
     {
         $app = new App;
         $app->get('/[{name}]', function ($response, $name = 'john doe') {
@@ -72,6 +72,44 @@ public function injects_default_value_in_optional_path_parameter()
         $this->assertEquals('Hello john doe', (string) $response->getBody());
     }
 
+    /**
+     * @test
+     */
+    public function injects_request_attribute()
+    {
+        $app = new App;
+        // Let's add a middleware that adds a request attribute
+        $app->add(function (ServerRequestInterface $request, $response, $next) {
+            return $next($request->withAttribute('name', 'Bob'), $response);
+        });
+        $app->get('/', function ($name, $response) {
+            $response->getBody()->write('Hello ' . $name);
+            return $response;
+        });
+
+        $response = $app->callMiddlewareStack(RequestFactory::create('/'), new Response);
+        $this->assertEquals('Hello Bob', $response->getBody()->__toString());
+    }
+
+    /**
+     * @test
+     */
+    public function injects_route_placeholder_over_request_attribute()
+    {
+        $app = new App;
+        $app->add(function (ServerRequestInterface $request, $response, $next) {
+            return $next($request->withAttribute('name', 'Bob'), $response);
+        });
+        $app->get('/{name}', function ($name, $response) {
+            $response->getBody()->write('Hello ' . $name);
+            return $response;
+        });
+
+        $response = $app->callMiddlewareStack(RequestFactory::create('/matt'), new Response);
+        // The route placeholder has priority over the request attribute
+        $this->assertEquals('Hello matt', (string) $response->getBody());
+    }
+
     /**
      * @test
      */