Merge branch 'prototype/mvc-module' of https://github.com/weierophinn…

…ey/zf2 into prototype/mvc-module

src/EventManager.php

@@ -26,7 +26,9 @@
 use Zend\Stdlib\CallbackHandler,
     Zend\Stdlib\Exception\InvalidCallbackException,
     Zend\Stdlib\PriorityQueue,
-    ArrayObject;
+    ArrayObject,
+    SplPriorityQueue,
+    Traversable;
 
 /**
  * Event manager: notification system
@@ -345,62 +347,84 @@ protected function triggerListeners($event, EventDescription $e, $callback)
     {
         $responses = new ResponseCollection;
 
-        $listeners = $this->getListeners($event);
+        $listeners = clone $this->getListeners($event);
+        foreach ($this->getStaticListeners($event) as $listener) {
+            $priority = $listener->getOption('priority');
+            if (null === $priority) {
+                $priority = 1;
+            } elseif (is_array($priority)) {
+                // If we have an array, likely using PriorityQueue. Grab first
+                // element of the array, as that's the actual priority.
+                $priority = array_shift($priority);
+            }
+            $listeners->insert($listener, $priority);
+        }
+
         if ($listeners->isEmpty()) {
-            return $this->triggerStaticListeners($callback, $e, $responses);
+            return $responses;
         }
 
         foreach ($listeners as $listener) {
+            // If we have an invalid listener, detach it, and move on to the next
+            if (!$listener->isValid()) {
+                $this->detach($listener);
+                continue;
+            }
+
+            // Trigger the listener's callback, and push its result onto the 
+            // response collection
             $responses->push(call_user_func($listener->getCallback(), $e));
+
+            // If the event was asked to stop propagating, do so
             if ($e->propagationIsStopped()) {
                 $responses->setStopped(true);
                 break;
             }
+
+            // If the result causes our validation callback to return true, 
+            // stop propagation
             if (call_user_func($callback, $responses->last())) {
                 $responses->setStopped(true);
                 break;
             }
         }
 
-        if (!$responses->stopped()) {
-            $this->triggerStaticListeners($callback, $e, $responses);
-        }
         return $responses;
     }
 
     /**
-     * Emit listeners matching the current identifier found in the static listener
-     *
-     * @param  callback $callback
-     * @param  Event $event
-     * @param  ResponseCollection $responses
-     * @return ResponseCollection
+     * Get list of all listeners attached to the static collection for 
+     * identifiers registered by this instance
+     * 
+     * @param  string $event 
+     * @return array
      */
-    protected function triggerStaticListeners($callback, Event $event, ResponseCollection $responses)
+    protected function getStaticListeners($event)
     {
         if (!$staticConnections = $this->getStaticConnections()) {
-            return $responses;
+            return array();
         }
 
-        $identifiers = (array) $this->identifier;
+        $identifiers     = (array) $this->identifier;
+        $staticListeners = array();
 
         foreach ($identifiers as $id) {
-            if (!$listeners = $staticConnections->getListeners($id, $event->getName())) {
+            if (!$listeners = $staticConnections->getListeners($id, $event)) {
+                continue;
+            }
+
+            if (!is_array($listeners) && !($listeners instanceof Traversable)) {
                 continue;
             }
+
             foreach ($listeners as $listener) {
-                $responses->push(call_user_func($listener->getCallback(), $event));
-                if ($event->propagationIsStopped()) {
-                    $responses->setStopped(true);
-                    break;
-                }
-                if (call_user_func($callback, $responses->last())) {
-                    $responses->setStopped(true);
-                    break;
+                if (!$listener instanceof CallbackHandler) {
+                    continue;
                 }
+                $staticListeners[] = $listener;
             }
         }
 
-        return $responses;
+        return $staticListeners;
     }
 }

src/StaticEventManager.php

@@ -116,7 +116,7 @@ public static function resetInstance()
      * @param  int $priority Priority at which listener should execute
      * @return void
      */
-    public function attach($id, $event, $callback, $priority = 1000)
+    public function attach($id, $event, $callback, $priority = 1)
     {
         $ids = (array) $id;
         foreach ($ids as $id) {

test/EventManagerTest.php

@@ -445,4 +445,20 @@ public function testTriggerCanTakeAnOptionalCallbackArgumentToEmulateTriggerUnti
         });
         $this->assertTrue($responses->stopped());
     }
+
+    public function testWeakRefsAreHonoredWhenTriggering()
+    {
+        if (!class_exists('WeakRef', false)) {
+            $this->markTestSkipped('Requires pecl/weakref');
+        }
+
+        $functor = new TestAsset\Functor;
+        $this->events->attach('test', $functor);
+
+        unset($functor);
+
+        $result = $this->events->trigger('test', $this, array());
+        $message = $result->last();
+        $this->assertNull($message);
+    }
 }

test/StaticIntegrationTest.php

@@ -55,7 +55,7 @@ function ($e) use ($counter) {
         $this->assertEquals(1, $counter->count);
     }
 
-    public function testLocalHandlersAreExecutedPriorToStaticHandlers()
+    public function testLocalHandlersAreExecutedPriorToStaticHandlersWhenSetWithSamePriority()
     {
         $test = (object) array('results' => array());
         StaticEventManager::getInstance()->attach(
@@ -73,7 +73,7 @@ function ($e) use ($test) {
         $this->assertEquals(array('local', 'static'), $test->results);
     }
 
-    public function testLocalHandlersAreExecutedPriorToStaticHandlersRegardlessOfPriority()
+    public function testLocalHandlersAreExecutedInPriorityOrderRegardlessOfStaticOrLocalRegistration()
     {
         $test = (object) array('results' => array());
         StaticEventManager::getInstance()->attach(
@@ -95,7 +95,7 @@ function ($e) use ($test) {
             $test->results[] = 'local3';
         }, 15000); // highest priority
         $class->foo();
-        $this->assertEquals(array('local3', 'local2', 'local', 'static'), $test->results);
+        $this->assertEquals(array('local3', 'static', 'local2', 'local'), $test->results);
     }
 
     public function testPassingNullValueToSetStaticConnectionsDisablesStaticConnections()
@@ -131,4 +131,23 @@ function ($e) use ($counter) {
         $class->foo();
         $this->assertEquals(0, $counter->count);
     }
+
+    public function testTriggerMergesPrioritiesOfStaticAndInstanceListeners()
+    {
+        $test = (object) array('results' => array());
+        StaticEventManager::getInstance()->attach(
+            'ZendTest\EventManager\TestAsset\ClassWithEvents', 
+            'foo', 
+            function ($e) use ($test) {
+                $test->results[] = 'static';
+            },
+            100
+        );
+        $class = new TestAsset\ClassWithEvents();
+        $class->events()->attach('foo', function ($e) use ($test) {
+            $test->results[] = 'local';
+        }, -100);
+        $class->foo();
+        $this->assertEquals(array('static', 'local'), $test->results);
+    }
 }

test/TestAsset/Functor.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace ZendTest\EventManager\TestAsset;
+
+class Functor
+{
+    public function __invoke($e)
+    {
+        return __METHOD__;
+    }
+}