PHP7 Chain Of Responsibilities

Behavioral/ChainOfResponsibilities/Handler.php

@@ -2,77 +2,42 @@
 
 namespace DesignPatterns\Behavioral\ChainOfResponsibilities;
 
-/**
- * Handler is a generic handler in the chain of responsibilities.
- *
- * Yes you could have a lighter CoR with a simpler handler but if you want your CoR
- * to be extendable and decoupled, it's a better idea to do things like that in real
- * situations. Usually, a CoR is meant to be changed everytime and evolves, that's
- * why we slice the workflow in little bits of code.
- */
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
 abstract class Handler
 {
     /**
-     * @var Handler
+     * @var Handler|null
      */
     private $successor = null;
 
-    /**
-     * Append a responsibility to the end of chain.
-     *
-     * A prepend method could be done with the same spirit
-     *
-     * You could also send the successor in the constructor but in PHP that is a
-     * bad idea because you have to remove the type-hint of the parameter because
-     * the last handler has a null successor.
-     *
-     * And if you override the constructor, that Handler can no longer have a
-     * successor. One solution is to provide a NullObject (see pattern).
-     * It is more preferable to keep the constructor "free" to inject services
-     * you need with the DiC of symfony2 for example.
-     *
-     * @param Handler $handler
-     */
-    final public function append(Handler $handler)
+    public function __construct(Handler $handler = null)
     {
-        if (is_null($this->successor)) {
-            $this->successor = $handler;
-        } else {
-            $this->successor->append($handler);
-        }
+        $this->successor = $handler;
     }
 
     /**
-     * Handle the request.
-     *
      * This approach by using a template method pattern ensures you that
-     * each subclass will not forget to call the successor. Besides, the returned
-     * boolean value indicates you if the request have been processed or not.
+     * each subclass will not forget to call the successor
      *
-     * @param Request $req
+     * @param RequestInterface $request
      *
-     * @return bool
+     * @return string|null
      */
-    final public function handle(Request $req)
+    final public function handle(RequestInterface $request)
     {
-        $req->forDebugOnly = get_called_class();
-        $processed = $this->processing($req);
-        if (!$processed) {
+        $processed = $this->processing($request);
+
+        if ($processed === null) {
             // the request has not been processed by this handler => see the next
-            if (!is_null($this->successor)) {
-                $processed = $this->successor->handle($req);
+            if ($this->successor !== null) {
+                $processed = $this->successor->handle($request);
             }
         }
 
         return $processed;
     }
 
-    /**
-     * Each concrete handler has to implement the processing of the request.
-     *
-     * @param Request $req
-     *
-     * @return bool true if the request has been processed
-     */
-    abstract protected function processing(Request $req);
+    abstract protected function processing(RequestInterface $request);
 }

Behavioral/ChainOfResponsibilities/README.rst

@@ -33,12 +33,6 @@ Code
 
 You can also find these code on `GitHub`_
 
-Request.php
-
-.. literalinclude:: Request.php
-   :language: php
-   :linenos:
-
 Handler.php
 
 .. literalinclude:: Handler.php

Behavioral/ChainOfResponsibilities/Request.php

@@ -1,19 +0,0 @@
-<?php
-
-namespace DesignPatterns\Behavioral\ChainOfResponsibilities;
-
-/**
- * Request is a request which goes through the chain of responsibilities.
- *
- * About the request: Sometimes, you don't need an object, just an integer or
- * an array. But in this case of a full example, I've made a class to illustrate
- * this important idea in the CoR (Chain of Responsibilities). In the real world,
- * I recommend to always use a class, even a \stdClass if you want, it proves
- * to be more adaptive because a single handler doesn't know much about the
- * outside world and it is more difficult if, one day, you want to add some
- * criterion in a decision process.
- */
-class Request
-{
-    // getter and setter but I don't want to generate too much noise in handlers
-}

Behavioral/ChainOfResponsibilities/Responsible/FastStorage.php

@@ -1,37 +0,0 @@
-<?php
-
-namespace DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible;
-
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Handler;
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Request;
-
-class FastStorage extends Handler
-{
-    /**
-     * @var array
-     */
-    protected $data = array();
-
-    /**
-     * @param array $data
-     */
-    public function __construct($data = array())
-    {
-        $this->data = $data;
-    }
-
-    protected function processing(Request $req)
-    {
-        if ('get' === $req->verb) {
-            if (array_key_exists($req->key, $this->data)) {
-                // the handler IS responsible and then processes the request
-                $req->response = $this->data[$req->key];
-                // instead of returning true, I could return the value but it proves
-                // to be a bad idea. What if the value IS "false" ?
-                return true;
-            }
-        }
-
-        return false;
-    }
-}

Behavioral/ChainOfResponsibilities/Responsible/HttpInMemoryCacheHandler.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible;
+
+use DesignPatterns\Behavioral\ChainOfResponsibilities\Handler;
+use Psr\Http\Message\RequestInterface;
+
+class HttpInMemoryCacheHandler extends Handler
+{
+    /**
+     * @var array
+     */
+    private $data;
+
+    /**
+     * @param array $data
+     * @param Handler|null $successor
+     */
+    public function __construct(array $data, Handler $successor = null)
+    {
+        parent::__construct($successor);
+
+        $this->data = $data;
+    }
+
+    /**
+     * @param RequestInterface $request
+     *
+     * @return string|null
+     */
+    protected function processing(RequestInterface $request)
+    {
+        $key = sprintf(
+            '%s?%s',
+            $request->getUri()->getPath(),
+            $request->getUri()->getQuery()
+        );
+
+        if ($request->getMethod() == 'GET' && isset($this->data[$key])) {
+            return $this->data[$key];
+        }
+
+        return null;
+    }
+}

Behavioral/ChainOfResponsibilities/Responsible/SlowDatabaseHandler.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible;
+
+use DesignPatterns\Behavioral\ChainOfResponsibilities\Handler;
+use Psr\Http\Message\RequestInterface;
+
+class SlowDatabaseHandler extends Handler
+{
+    /**
+     * @param RequestInterface $request
+     *
+     * @return string|null
+     */
+    protected function processing(RequestInterface $request)
+    {
+        // this is a mockup, in production code you would ask a slow (compared to in-memory) DB for the results
+
+        return 'Hello World!';
+    }
+}

Behavioral/ChainOfResponsibilities/Responsible/SlowStorage.php

@@ -1,44 +0,0 @@
-<?php
-
-namespace DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible;
-
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Handler;
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Request;
-
-/**
- * This is mostly the same code as FastStorage but in fact, it may greatly differs.
- *
- * One important fact about CoR: each item in the chain MUST NOT assume its position
- * in the chain. A CoR is not responsible if the request is not handled UNLESS
- * you make an "ExceptionHandler" which throws exception if the request goes there.
- *
- * To be really extendable, each handler doesn't know if there is something after it.
- */
-class SlowStorage extends Handler
-{
-    /**
-     * @var array
-     */
-    protected $data = array();
-
-    /**
-     * @param array $data
-     */
-    public function __construct($data = array())
-    {
-        $this->data = $data;
-    }
-
-    protected function processing(Request $req)
-    {
-        if ('get' === $req->verb) {
-            if (array_key_exists($req->key, $this->data)) {
-                $req->response = $this->data[$req->key];
-
-                return true;
-            }
-        }
-
-        return false;
-    }
-}

Behavioral/ChainOfResponsibilities/Tests/ChainTest.php

@@ -2,80 +2,50 @@
 
 namespace DesignPatterns\Behavioral\ChainOfResponsibilities\Tests;
 
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Request;
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible;
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\FastStorage;
-use DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\SlowStorage;
+use DesignPatterns\Behavioral\ChainOfResponsibilities\Handler;
+use DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\HttpInMemoryCacheHandler;
+use DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\SlowDatabaseHandler;
 
-/**
- * ChainTest tests the CoR.
- */
 class ChainTest extends \PHPUnit_Framework_TestCase
 {
     /**
-     * @var FastStorage
+     * @var Handler
      */
-    protected $chain;
+    private $chain;
 
     protected function setUp()
     {
-        $this->chain = new FastStorage(array('bar' => 'baz'));
-        $this->chain->append(new SlowStorage(array('bar' => 'baz', 'foo' => 'bar')));
-    }
-
-    public function makeRequest()
-    {
-        $request = new Request();
-        $request->verb = 'get';
-
-        return array(
-            array($request),
+        $this->chain = new HttpInMemoryCacheHandler(
+            ['/foo/bar?index=1' => 'Hello In Memory!'],
+            new SlowDatabaseHandler()
         );
     }
 
-    /**
-     * @dataProvider makeRequest
-     */
-    public function testFastStorage($request)
+    public function testCanRequestKeyInFastStorage()
     {
-        $request->key = 'bar';
-        $ret = $this->chain->handle($request);
+        $uri = $this->createMock('Psr\Http\Message\UriInterface');
+        $uri->method('getPath')->willReturn('/foo/bar');
+        $uri->method('getQuery')->willReturn('index=1');
 
-        $this->assertTrue($ret);
-        $this->assertObjectHasAttribute('response', $request);
-        $this->assertEquals('baz', $request->response);
-        // despite both handle owns the 'bar' key, the FastStorage is responding first
-        $className = 'DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\FastStorage';
-        $this->assertEquals($className, $request->forDebugOnly);
+        $request = $this->createMock('Psr\Http\Message\RequestInterface');
+        $request->method('getMethod')
+            ->willReturn('GET');
+        $request->method('getUri')->willReturn($uri);
+
+        $this->assertEquals('Hello In Memory!', $this->chain->handle($request));
     }
 
-    /**
-     * @dataProvider makeRequest
-     */
-    public function testSlowStorage($request)
+    public function testCanRequestKeyInSlowStorage()
     {
-        $request->key = 'foo';
-        $ret = $this->chain->handle($request);
+        $uri = $this->createMock('Psr\Http\Message\UriInterface');
+        $uri->method('getPath')->willReturn('/foo/baz');
+        $uri->method('getQuery')->willReturn('');
 
-        $this->assertTrue($ret);
-        $this->assertObjectHasAttribute('response', $request);
-        $this->assertEquals('bar', $request->response);
-        // FastStorage has no 'foo' key, the SlowStorage is responding
-        $className = 'DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\SlowStorage';
-        $this->assertEquals($className, $request->forDebugOnly);
-    }
+        $request = $this->createMock('Psr\Http\Message\RequestInterface');
+        $request->method('getMethod')
+            ->willReturn('GET');
+        $request->method('getUri')->willReturn($uri);
 
-    /**
-     * @dataProvider makeRequest
-     */
-    public function testFailure($request)
-    {
-        $request->key = 'kurukuku';
-        $ret = $this->chain->handle($request);
-
-        $this->assertFalse($ret);
-        // the last responsible :
-        $className = 'DesignPatterns\Behavioral\ChainOfResponsibilities\Responsible\SlowStorage';
-        $this->assertEquals($className, $request->forDebugOnly);
+        $this->assertEquals('Hello World!', $this->chain->handle($request));
     }
 }