Use events instead of callbacks.

Signed-off-by: Jason Lewis <[email protected]>

Author: jasonlewis

src/Event/ResponseIsMorphing.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Dingo\Api\Event;
+
+use Dingo\Api\Http\Response;
+
+class ResponseIsMorphing
+{
+    /**
+     * Response instance.
+     *
+     * @var \Dingo\Api\Http\Response
+     */
+    public $response;
+
+    /**
+     * Response content.
+     *
+     * @var string
+     */
+    public $content;
+
+    /**
+     * Create a new response is morphing event. Content is passed by reference
+     * so that multiple listeners can modify content.
+     *
+     * @param \Dingo\Api\Http\Response $response
+     * @param string                   $content
+     *
+     * @return void
+     */
+    public function __construct(Response $response, &$content)
+    {
+        $this->response = $response;
+        $this->content = &$content;
+    }
+}

src/Event/ResponseWasMorphed.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Dingo\Api\Event;
+
+use Dingo\Api\Http\Response;
+
+class ResponseWasMorphed extends ResponseIsMorphing
+{
+}

src/Http/Response.php

@@ -2,13 +2,14 @@
 
 namespace Dingo\Api\Http;
 
-use Closure;
 use ArrayObject;
+use Dingo\Api\Event;
 use UnexpectedValueException;
 use Dingo\Api\Transformer\Binding;
 use Illuminate\Contracts\Support\Arrayable;
 use Symfony\Component\HttpFoundation\Cookie;
 use Illuminate\Http\Response as IlluminateResponse;
+use Illuminate\Events\Dispatcher as EventDispatcher;
 use Illuminate\Database\Eloquent\Model as EloquentModel;
 use Dingo\Api\Transformer\Factory as TransformerFactory;
 use Illuminate\Database\Eloquent\Collection as EloquentCollection;
@@ -38,18 +39,11 @@ class Response extends IlluminateResponse
     protected static $transformer;
 
     /**
-     * Array of user-defined morphing callbacks.
+     * Event dispatcher instance.
      *
-     * @var array
-     */
-    protected static $morphingCallbacks = [];
-
-    /**
-     * Array of user-defined morphed callbacks.
-     *
-     * @var array
+     * @var \Illuminate\Events\Dispatcher
      */
-    protected static $morphedCallbacks = [];
+    protected static $events;
 
     /**
      * Create a new response instance.
@@ -95,7 +89,7 @@ public function morph($format = 'json')
     {
         $this->content = $this->getOriginalContent();
 
-        $this->fireMorphingCallbacks();
+        $this->fireMorphingEvent();
 
         if (isset(static::$transformer) && static::$transformer->transformableResponse($this->content)) {
             $this->content = static::$transformer->transform($this->content);
@@ -107,7 +101,7 @@ public function morph($format = 'json')
 
         $this->headers->set('content-type', $formatter->getContentType());
 
-        $this->fireMorphedCallbacks();
+        $this->fireMorphedEvent();
 
         if ($this->content instanceof EloquentModel) {
             $this->content = $formatter->formatEloquentModel($this->content);
@@ -123,39 +117,31 @@ public function morph($format = 'json')
     }
 
     /**
-     * Fire the morphed callbacks.
+     * Fire the morphed event.
      *
      * @return void
      */
-    protected function fireMorphedCallbacks()
+    protected function fireMorphedEvent()
     {
-        $this->fireCallbacks(static::$morphedCallbacks);
-    }
+        if (! static::$events) {
+            return;
+        }
 
-    /**
-     * Fire the morphing callbacks.
-     *
-     * @return void
-     */
-    protected function fireMorphingCallbacks()
-    {
-        $this->fireCallbacks(static::$morphingCallbacks);
+        static::$events->fire(new Event\ResponseWasMorphed($this, $this->content));
     }
 
     /**
-     * Fire the callbacks with the content and response instance as parameters.
-     *
-     * @param array $callbacks
+     * Fire the morphing event.
      *
      * @return void
      */
-    protected function fireCallbacks(array $callbacks)
+    protected function fireMorphingEvent()
     {
-        foreach ($callbacks as $callback) {
-            if ($response = call_user_func($callback, $this->content, $this)) {
-                $this->content = $response;
-            }
+        if (! static::$events) {
+            return;
         }
+
+        static::$events->fire(new Event\ResponseIsMorphing($this, $this->content));
     }
 
     /**
@@ -177,27 +163,15 @@ public function setContent($content)
     }
 
     /**
-     * Add a callback for when the response is about to be morphed.
-     *
-     * @param \Closure $callback
-     *
-     * @return void
-     */
-    public static function morphing(Closure $callback)
-    {
-        static::$morphingCallbacks[] = $callback;
-    }
-
-    /**
-     * Add a callback for when the response has been morphed.
+     * Set the event dispatcher instance.
      *
-     * @param \Closure $callback
+     * @param \Illuminate\Events\Dispatcher $events
      *
      * @return void
      */
-    public static function morphed(Closure $callback)
+    public static function setEventDispatcher(EventDispatcher $events)
     {
-        static::$morphedCallbacks[] = $callback;
+        static::$events = $events;
     }
 
     /**

src/Provider/ApiServiceProvider.php

@@ -31,6 +31,7 @@ public function boot()
 
         Http\Response::setFormatters($this->prepareConfigValues($this->app['config']['api.formats']));
         Http\Response::setTransformer($this->app['api.transformer']);
+        Http\Response::setEventDispatcher($this->app['events']);
 
         $this->app->rebinding('api.routes', function ($app, $routes) {
             $app['api.url']->setRouteCollections($routes);

tests/Http/ResponseTest.php

@@ -9,24 +9,18 @@
 use PHPUnit_Framework_TestCase;
 use Dingo\Api\Transformer\Binding;
 use Dingo\Api\Http\Response\Format\Json;
+use Illuminate\Events\Dispatcher as EventDispatcher;
 
 class ResponseTest extends PHPUnit_Framework_TestCase
 {
+    public function setUp()
+    {
+        Response::setEventDispatcher($this->events = new EventDispatcher);
+    }
+
     public function tearDown()
     {
         m::close();
-
-        $reflection = new ReflectionClass('Dingo\Api\Http\Response');
-
-        $property = $reflection->getProperty('morphedCallbacks');
-
-        $property->setAccessible(true);
-        $property->setValue([]);
-
-        $property = $reflection->getProperty('morphingCallbacks');
-
-        $property->setAccessible(true);
-        $property->setValue([]);
     }
 
     /**
@@ -70,31 +64,33 @@ public function testBuildingWithCustomStatusCodeAndHeaders()
         $this->assertEquals(302, $response->getStatusCode());
     }
 
-    public function testChangingContentWithCallbacks()
+    public function testChangingContentWithEvents()
     {
-        Response::morphed(function ($content, Response $response) {
-            $content['foo'] = 'bam!';
-
-            return $content;
+        $this->events->listen('Dingo\Api\Event\ResponseWasMorphed', function ($event) {
+            $event->content['foo'] = 'bam!';
         });
 
         Response::addFormatter('json', new Json);
 
         $response = new Response(['foo' => 'bar']);
 
         $this->assertEquals('{"foo":"bam!"}', $response->morph('json')->getContent());
+
+        $this->events->forget('Dingo\Api\Event\ResponseWasMorphed');
     }
 
-    public function testChangingResponseHeadersWithCallbacks()
+    public function testChangingResponseHeadersWithEvents()
     {
-        Response::morphing(function ($content, Response $response) {
-            $response->headers->set('x-foo', 'bar');
+        $this->events->listen('Dingo\Api\Event\ResponseIsMorphing', function ($event) {
+            $event->response->headers->set('x-foo', 'bar');
         });
 
         Response::addFormatter('json', new Json);
 
         $response = new Response(['foo' => 'bar']);
 
         $this->assertEquals('bar', $response->morph('json')->headers->get('x-foo'));
+
+        $this->events->forget('Dingo\Api\Event\ResponseIsMorphing');
     }
 }