Merge branch 'develop' of git://github.com/zendframework/zf2 into hot…

…fix/cache-empty-namespace
zendframework · Dec 13, 2012 · ba6e7b6 · ba6e7b6
commit ba6e7b6
Show file tree

Hide file tree

Showing 11 changed files with 319 additions and 42 deletions.
diff --git a/src/EventManager.php b/src/EventManager.php
@@ -144,7 +144,7 @@ public function getIdentifiers()
      */
     public function setIdentifiers($identifiers)
     {
-        if (is_array($identifiers) || $identifiers instanceof \Traversable) {
+        if (is_array($identifiers) || $identifiers instanceof Traversable) {
             $this->identifiers = array_unique((array) $identifiers);
         } elseif ($identifiers !== null) {
             $this->identifiers = array($identifiers);
@@ -160,7 +160,7 @@ public function setIdentifiers($identifiers)
      */
     public function addIdentifiers($identifiers)
     {
-        if (is_array($identifiers) || $identifiers instanceof \Traversable) {
+        if (is_array($identifiers) || $identifiers instanceof Traversable) {
             $this->identifiers = array_unique($this->identifiers + (array) $identifiers);
         } elseif ($identifiers !== null) {
             $this->identifiers = array_unique(array_merge($this->identifiers, array($identifiers)));
@@ -447,19 +447,15 @@ protected function triggerListeners($event, EventInterface $e, $callback = null)
         $wildcardListeners       = $this->getListeners('*');
         if (count($sharedListeners) || count($sharedWildcardListeners) || count($wildcardListeners)) {
             $listeners = clone $listeners;
-        }
-
-        // Shared listeners on this specific event
-        $this->insertListeners($listeners, $sharedListeners);
 
-        // Shared wildcard listeners
-        $this->insertListeners($listeners, $sharedWildcardListeners);
+            // Shared listeners on this specific event
+            $this->insertListeners($listeners, $sharedListeners);
 
-        // Add wildcard listeners
-        $this->insertListeners($listeners, $wildcardListeners);
+            // Shared wildcard listeners
+            $this->insertListeners($listeners, $sharedWildcardListeners);
 
-        if ($listeners->isEmpty()) {
-            return $responses;
+            // Add wildcard listeners
+            $this->insertListeners($listeners, $wildcardListeners);
         }
 
         foreach ($listeners as $listener) {
@@ -535,10 +531,6 @@ protected function getSharedListeners($event)
      */
     protected function insertListeners($masterListeners, $listeners)
     {
-        if (!count($listeners)) {
-            return;
-        }
-
         foreach ($listeners as $listener) {
             $priority = $listener->getMetadatum('priority');
             if (null === $priority) {

diff --git a/src/EventManagerAwareTrait.php b/src/EventManagerAwareTrait.php
@@ -0,0 +1,22 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ * @package   Zend_EventManager
+ */
+
+namespace Zend\EventManager;
+
+use \Zend\EventManager\ProvidesEvents;
+
+/**
+ * @category Zend
+ * @package  Zend_EventManager
+ */
+trait EventManagerAwareTrait
+{
+    use ProvidesEvents;
+}
diff --git a/src/SharedEventAggregateAwareInterface.php b/src/SharedEventAggregateAwareInterface.php
@@ -0,0 +1,38 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ * @package   Zend_EventManager
+ */
+
+namespace Zend\EventManager;
+
+
+/**
+ * Interface for allowing attachment of shared aggregate listeners.
+ *
+ * @category   Zend
+ * @package    Zend_EventManager
+ */
+interface SharedEventAggregateAwareInterface
+{
+    /**
+     * Attach a listener aggregate
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @param  int $priority If provided, a suggested priority for the aggregate to use
+     * @return mixed return value of {@link SharedListenerAggregateInterface::attachShared()}
+     */
+    public function attachAggregate(SharedListenerAggregateInterface $aggregate, $priority = 1);
+
+    /**
+     * Detach a listener aggregate
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @return mixed return value of {@link SharedListenerAggregateInterface::detachShared()}
+    */
+    public function detachAggregate(SharedListenerAggregateInterface $aggregate);
+}
diff --git a/src/SharedEventManager.php b/src/SharedEventManager.php
@@ -23,7 +23,9 @@
  * @category   Zend
  * @package    Zend_EventManager
  */
-class SharedEventManager implements SharedEventManagerInterface
+class SharedEventManager implements
+    SharedEventAggregateAwareInterface,
+    SharedEventManagerInterface
 {
     /**
      * Identifiers with event connections
@@ -77,6 +79,22 @@ public function attach($id, $event, $callback, $priority = 1)
         return $listeners[0];
     }
 
+    /**
+     * Attach a listener aggregate
+     *
+     * Listener aggregates accept an EventManagerInterface instance, and call attachShared()
+     * one or more times, typically to attach to multiple events using local
+     * methods.
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @param  int $priority If provided, a suggested priority for the aggregate to use
+     * @return mixed return value of {@link ListenerAggregateInterface::attachShared()}
+     */
+    public function attachAggregate(SharedListenerAggregateInterface $aggregate, $priority = 1)
+    {
+        return $aggregate->attachShared($this, $priority);
+    }
+
     /**
      * Detach a listener from an event offered by a given resource
      *
@@ -92,6 +110,20 @@ public function detach($id, CallbackHandler $listener)
         return $this->identifiers[$id]->detach($listener);
     }
 
+    /**
+     * Detach a listener aggregate
+     *
+     * Listener aggregates accept an SharedEventManagerInterface instance, and call detachShared()
+     * of all previously attached listeners.
+     *
+     * @param  SharedListenerAggregateInterface $aggregate
+     * @return mixed return value of {@link SharedListenerAggregateInterface::detachShared()}
+     */
+    public function detachAggregate(SharedListenerAggregateInterface $aggregate)
+    {
+        return $aggregate->detachShared($this);
+    }
+
     /**
      * Retrieve all registered events for a given resource
      *

diff --git a/src/SharedEventManagerInterface.php b/src/SharedEventManagerInterface.php
@@ -66,5 +66,4 @@ public function getEvents($id);
      * @return bool
      */
     public function clearListeners($id, $event = null);
-
 }
diff --git a/src/SharedListenerAggregateInterface.php b/src/SharedListenerAggregateInterface.php
@@ -0,0 +1,42 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ * @package   Zend_EventManager
+ */
+
+namespace Zend\EventManager;
+
+/**
+ * Interface for self-registering event listeners.
+ *
+ * Classes implementing this interface may be registered by name or instance
+ * with an SharedEventManager, without an event name. The {@link attach()} method will
+ * then be called with the current SharedEventManager instance, allowing the class to
+ * wire up one or more listeners.
+ *
+ * @category   Zend
+ * @package    Zend_EventManager
+ */
+interface SharedListenerAggregateInterface
+{
+    /**
+     * Attach one or more listeners
+     *
+     * Implementors may add an optional $priority argument; the SharedEventManager
+     * implementation will pass this to the aggregate.
+     *
+     * @param SharedEventManagerInterface $events
+     */
+    public function attachShared(SharedEventManagerInterface $events);
+
+    /**
+     * Detach all previously attached listeners
+     *
+     * @param SharedEventManagerInterface $events
+     */
+    public function detachShared(SharedEventManagerInterface $events);
+}
diff --git a/test/EventManagerAwareTraitTest.php b/test/EventManagerAwareTraitTest.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ * @package   Zend_EventManager
+ */
+
+namespace ZendTest\EventManager;
+
+use \PHPUnit_Framework_TestCase as TestCase;
+use \Zend\EventManager\EventManager;
+
+/**
+ * @requires PHP 5.4
+ */
+class EventManagerAwareTraitTest extends TestCase
+{
+    public function testSetEventManager()
+    {
+        $object = $this->getObjectForTrait('\Zend\EventManager\EventManagerAwareTrait');
+
+        $this->assertAttributeEquals(null, 'events', $object);
+
+        $eventManager = new EventManager;
+
+        $object->setEventManager($eventManager);
+
+        $this->assertAttributeEquals($eventManager, 'events', $object);
+    }
+
+    public function testGetEventManager()
+    {
+        $object = $this->getObjectForTrait('\Zend\EventManager\EventManagerAwareTrait');
+
+        $this->assertInstanceOf('\Zend\EventManager\EventManagerInterface', $object->getEventManager());
+
+        $eventManager = new EventManager;
+
+        $object->setEventManager($eventManager);
+
+        $this->assertSame($eventManager, $object->getEventManager());
+    }
+}
diff --git a/test/EventManagerTest.php b/test/EventManagerTest.php
@@ -277,10 +277,18 @@ public function testAttachAggregateReturnsAttachOfListenerAggregate()
     public function testCanDetachListenerAggregates()
     {
         // setup some other event listeners, to ensure appropriate items are detached
-        $listenerFooBar1 = $this->events->attach('foo.bar', function() { return true; });
-        $listenerFooBar2 = $this->events->attach('foo.bar', function() { return true; });
-        $listenerFooBaz1 = $this->events->attach('foo.baz', function() { return true; });
-        $listenerOther   = $this->events->attach('other', function() { return true; });
+        $listenerFooBar1 = $this->events->attach('foo.bar', function () {
+            return true;
+        });
+        $listenerFooBar2 = $this->events->attach('foo.bar', function () {
+            return true;
+        });
+        $listenerFooBaz1 = $this->events->attach('foo.baz', function () {
+            return true;
+        });
+        $listenerOther   = $this->events->attach('other', function () {
+            return true;
+        });
 
         $aggregate = new TestAsset\MockAggregate();
         $this->events->attachAggregate($aggregate);
@@ -307,10 +315,18 @@ public function testCanDetachListenerAggregates()
     public function testCanDetachListenerAggregatesViaDetach()
     {
         // setup some other event listeners, to ensure appropriate items are detached
-        $listenerFooBar1 = $this->events->attach('foo.bar', function() { return true; });
-        $listenerFooBar2 = $this->events->attach('foo.bar', function() { return true; });
-        $listenerFooBaz1 = $this->events->attach('foo.baz', function() { return true; });
-        $listenerOther   = $this->events->attach('other', function() { return true; });
+        $listenerFooBar1 = $this->events->attach('foo.bar', function () {
+            return true;
+        });
+        $listenerFooBar2 = $this->events->attach('foo.bar', function () {
+            return true;
+        });
+        $listenerFooBaz1 = $this->events->attach('foo.baz', function () {
+            return true;
+        });
+        $listenerOther   = $this->events->attach('other', function () {
+            return true;
+        });
 
         $aggregate = new TestAsset\MockAggregate();
         $this->events->attach($aggregate);
@@ -593,7 +609,7 @@ public function testListenersAttachedWithWildcardAreTriggeredForAllEvents()
     {
         $test     = new stdClass;
         $test->events = array();
-        $callback = function($e) use ($test) {
+        $callback = function ($e) use ($test) {
             $test->events[] = $e->getName();
         };
 
@@ -618,7 +634,7 @@ public function testSharedEventManagerAttachReturnsCallbackHandler()
         $callbackHandler = $shared->attach(
             'foo',
             'bar',
-            function($e) {
+            function ($e) {
                 return true;
             }
         );

diff --git a/test/FilterChainTest.php b/test/FilterChainTest.php
@@ -74,14 +74,14 @@ public function testRetrievingAttachedFiltersShouldReturnEmptyArrayWhenNoFilters
 
     public function testFilterChainShouldReturnLastResponse()
     {
-        $this->filterchain->attach(function($context, $params, $chain) {
+        $this->filterchain->attach(function ($context, $params, $chain) {
             if (isset($params['string'])) {
                 $params['string'] = trim($params['string']);
             }
             $return =  $chain->next($context, $params, $chain);
             return $return;
         });
-        $this->filterchain->attach(function($context, array $params) {
+        $this->filterchain->attach(function ($context, array $params) {
             $string = isset($params['string']) ? $params['string'] : '';
             return str_rot13($string);
         });
@@ -107,17 +107,17 @@ public function testInterceptingFilterShouldReceiveChain()
 
     public function testFilteringStopsAsSoonAsAFilterFailsToCallNext()
     {
-        $this->filterchain->attach(function($context, $params, $chain) {
+        $this->filterchain->attach(function ($context, $params, $chain) {
             if (isset($params['string'])) {
                 $params['string'] = trim($params['string']);
             }
             return $chain->next($context, $params, $chain);
         }, 10000);
-        $this->filterchain->attach(function($context, array $params) {
+        $this->filterchain->attach(function ($context, array $params) {
             $string = isset($params['string']) ? $params['string'] : '';
             return str_rot13($string);
         }, 1000);
-        $this->filterchain->attach(function($context, $params, $chain) {
+        $this->filterchain->attach(function ($context, $params, $chain) {
             $string = isset($params['string']) ? $params['string'] : '';
             return hash('md5', $string);
         }, 100);