Request 1878 (accepted)

php-sabre-event.spec Changed

@@ -6,7 +6,7 @@
 #
 # Please, preserve the changelog entries
 #
-%global gh_commit    5ee3adf5441c2fe53b8ceacff6db81e621ee884c
+%global gh_commit    337b6f5e10ea6e0b21e22c7e5788dd3883ae73ff
 %global gh_short     %(c=%{gh_commit}; echo ${c:0:7})
 %global gh_owner     fruux
 %global gh_project   sabre-event
@@ -14,7 +14,7 @@
 
 Name:           php-%{gh_project}
 Summary:        Lightweight library for event-based programming
-Version:        1.0.1
+Version:        2.0.2
 Release:        1%{?dist}
 
 URL:            http://sabre.io/event
@@ -49,7 +49,7 @@
 
 
 %prep
-%setup -q -n %{gh_project}-%{gh_commit}
+%setup -q -n %{gh_project}-%{version}
 
 : Create trivial PSR0 autoloader
 cat <<EOF | tee psr0.php
@@ -67,16 +67,15 @@
 
 %install
 # Install as a PSR-0 library
-mkdir -p %{buildroot}%{_datadir}/php
-cp -pr lib/Sabre %{buildroot}%{_datadir}/php/Sabre
+mkdir -p %{buildroot}%{_datadir}/php/Sabre
+cp -pr lib %{buildroot}%{_datadir}/php/Sabre/Event
 
 
 %check
 %if %{with_tests}
 : Run upstream test suite against installed library
-cd tests
 phpunit \
-  --bootstrap=../psr0.php \
+  --bootstrap=psr0.php \
   --include-path=%{buildroot}%{_datadir}/php \
   -d date.timezone=UTC
 %else
@@ -85,11 +84,14 @@
 
 
 %files
-%doc ChangeLog composer.json LICENSE README.md
+%doc CHANGELOG.md composer.json LICENSE README.md
 %{_datadir}/php/Sabre
 
 
 %changelog
+* Sat Dec 03 2016 Daniel Hoffend <dh@dotlan.net> - 2.0.2-1
+- update to 2.0.2
+
 * Fri Jun 13 2014 Remi Collet <remi@fedoraproject.org> - 1.0.1-1
 - update to 1.0.1
 - add provides php-composer(sabre/event)

0001-Use-ClassLoader-from-Symfony-instead-of-autoload.patch Deleted

debian.changelog Changed

@@ -1,6 +1,84 @@
-php-sabre-event (1.0.1-1) unstable; urgency=low
+php-sabre-event (2.0.2-3) unstable; urgency=low
+
+  * Updated Packaging for Kolab Winterfell
+  * merged with latest 2.0 Sabre/Event Debian Package
+
+ -- Daniel Hoffend <dh@ðotlan.net>  Sat, 03 Dec 2016 21:02:01 +0100
+
+php-sabre-event (2.0.2-2) unstable; urgency=medium
+
+  * Upload to unstable us needed by php-sabre-dav-2.1
+
+ -- David Prévot <taffit@debian.org>  Sun, 21 Jun 2015 09:38:00 -0400
+
+php-sabre-event (2.0.2-1) experimental; urgency=medium
+
+  * Use --bootstrap feature of PHPUnit instead of patches
+  * Update copyright (year)
+
+ -- David Prévot <taffit@debian.org>  Wed, 20 May 2015 14:30:37 -0400
+
+php-sabre-event (2.0.1-2) experimental; urgency=medium
+
+  * Update watch file
+  * Provide homemade autoload.php
+
+ -- David Prévot <taffit@debian.org>  Wed, 25 Feb 2015 22:37:35 -0400
+
+php-sabre-event (2.0.1-1) experimental; urgency=medium
+
+  [ Evert Pot ]
+  * Fix bugs related to ::once
+
+  [ David Prévot ]
+  * Bump standards version to 3.9.6
+
+ -- David Prévot <taffit@debian.org>  Fri, 10 Oct 2014 10:54:23 -0400
+
+php-sabre-event (2.0.0-1) experimental; urgency=medium
+
+  [ Evert Pot ]
+  * psr-4 directory layout.
+  * Made this an alpha version
+
+  [ David Prévot ]
+  * Update packaging, and upload to experimental
+
+ -- David Prévot <taffit@debian.org>  Mon, 23 Jun 2014 16:31:07 -0400
+
+php-sabre-event (1.0.1-3) unstable; urgency=low
 
   * Initlal Release for Kolab Winterfell
 
  -- hede <kolab983@der-he.de>  Sun, 04 Sep 2016 20:00:00 +0200
 
+php-sabre-event (1.0.1-2) unstable; urgency=medium
+
+  * Bump standards version to 3.9.6
+  * Update watch file
+  * Track 1.0
+  * Provide homemade autoload.php
+
+ -- David Prévot <taffit@debian.org>  Wed, 25 Feb 2015 22:59:32 -0400
+
+php-sabre-event (1.0.1-1) unstable; urgency=medium
+
+  [ David Prévot ]
+  * Set maintainer to Debian PHP PEAR
+  * Run the test suite on packaging
+  * Add DEP-8 compliant tests
+  * Update Homepage
+  * Update copyright
+
+  [ Evert Pot ]
+  * Issue #4. Compatibility for PHP < 5.4.14.
+  * Updated copyrights and link to license
+  * Updated a few links
+
+ -- David Prévot <taffit@debian.org>  Sat, 14 Jun 2014 21:20:41 -0400
+
+php-sabre-event (1.0.0-1) unstable; urgency=low
+
+  * Initial release (Closes: #729432)
+
+ -- David Prévot <taffit@debian.org>  Tue, 12 Nov 2013 15:54:32 -0400

debian.control Changed

debian.rules Changed

debian.series Changed

debian.tar.gz/clean Added

debian.tar.gz/copyright Changed

debian.tar.gz/docs Added

debian.tar.gz/install Changed

debian.tar.gz/watch Changed

php-sabre-event.dsc Changed

@@ -2,17 +2,20 @@
 Source: php-sabre-event
 Binary: php-sabre-event
 Architecture: all
-Version: 1.0.1-1
-Maintainer: Kolab for Debian testing <devel@lists.kolab.org>
+Version: 2.0.2-3
+Maintainer: Kolab for Debian <devel@lists.kolab.org>
 Uploaders: hede <kolab983@der-he.de>
-Build-Depends: debhelper (>= 9), phpunit, php-symfony-classloader, pkg-php-tools (>= 1.7~)
+Build-Depends: debhelper (>= 9),
+               phpab,
+               phpunit,
+               pkg-php-tools (>= 1.7~)
 Standards-Version: 3.9.6
 Homepage: http://sabre.io/event/
-Vcs-Git: git://anonscm.debian.org/pkg-php/php-sabre-event.git -b 1.0
+Vcs-Git: git://anonscm.debian.org/pkg-php/php-sabre-event.git -b 2.0
 Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-php/php-sabre-event.git
 Package-List:
  php-sabre-event deb php optional arch=all
 Files:
- 00000000000000000000000000000000 0 sabre-event-1.0.1.tar.gz
+ 00000000000000000000000000000000 0 sabre-event-2.0.2.tar.gz
  00000000000000000000000000000000 0 debian.tar.gz

sabre-event-1.0.1.tar.gz/ChangeLog Deleted

sabre-event-1.0.1.tar.gz/lib/Sabre Deleted

sabre-event-1.0.1.tar.gz/lib/Sabre/Event Deleted

sabre-event-1.0.1.tar.gz/lib/Sabre/Event/EventEmitter.php Deleted

sabre-event-1.0.1.tar.gz/lib/Sabre/Event/EventEmitterInterface.php Deleted

@@ -1,80 +0,0 @@
-<?php
-
-namespace Sabre\Event;
-
-/**
- * Event Emitter Interface
- *
- * Anything that accepts listeners and emits events should implement this
- * interface.
- *
- * @copyright Copyright (C) 2013-2014 fruux GmbH. All rights reserved.
- * @author Evert Pot (http://evertpot.com/)
- * @license http://sabre.io/license/
- */
-interface EventEmitterInterface {
-
-    /**
-     * Subscribe to an event.
-     *
-     * @param string $eventName
-     * @param callable $callBack
-     * @param int $priority
-     * @return void
-     */
-    public function on($eventName, callable $callBack, $priority = 100);
-
-    /**
-     * Subscribe to an event exactly once.
-     *
-     * @param string $eventName
-     * @param callable $callBack
-     * @param int $priority
-     * @return void
-     */
-    public function once($eventName, callable $callBack, $priority = 100);
-
-    /**
-     * Emits an event.
-     *
-     * This method will return true if 0 or more listeners were succesfully
-     * handled. false is returned if one of the events broke the event chain.
-     *
-     * @param string $eventName
-     * @param array $arguments
-     * @return bool
-     */
-    public function emit($eventName, array $arguments = []);
-
-
-    /**
-     * Returns the list of listeners for an event.
-     *
-     * The list is returned as an array. Every item is another array with 2
-     * elements: priority and the callback.
-     *
-     * The array is returned by reference, and can therefore be used to
-     * manipulate the list of events.
-     *
-     * @param string $eventName
-     * @return array
-     */
-    public function & listeners($eventName);
-
-    /**
-     * Removes a specific listener from an event.
-     *
-     * @param string $eventName
-     * @param callable $listener
-     * @return void
-     */
-    public function removeListener($eventName, callable $listener);
-
-    /**
-     * Removes all listeners from the specified event.
-     *
-     * @param string $eventName
-     * @return void
-     */
-    public function removeAllListeners($eventName);
-}

sabre-event-1.0.1.tar.gz/lib/Sabre/Event/EventEmitterTrait.php Deleted

@@ -1,148 +0,0 @@
-<?php
-
-namespace Sabre\Event;
-
-/**
- * Event Emitter Trait
- *
- * This traits contains all the basic functions to implement an
- * EventEmitterInterface.
- *
- * Using the trait + interface allows you to add EventEmitter capabilities
- * without having to change your base-class.
- *
- * @copyright Copyright (C) 2013 fruux GmbH. All rights reserved.
- * @author Evert Pot (http://evertpot.com/)
- * @license https://raw.github.com/fruux/sabre-event/master/LICENSE
- */
-trait EventEmitterTrait {
-
-    /**
-     * The list of listeners
-     *
-     * @var array
-     */
-    protected $listeners = [];
-
-    /**
-     * Subscribe to an event.
-     *
-     * @param string $eventName
-     * @param callable $callBack
-     * @param int $priority
-     * @return void
-     */
-    public function on($eventName, callable $callBack, $priority = 100) {
-
-        $listeners =& $this->listeners($eventName);
-        $listeners[] = [$priority, $callBack];
-        usort($listeners, function($a, $b) {
-
-            return $a[0]-$b[0];
-
-        });
-
-    }
-
-    /**
-     * Subscribe to an event exactly once.
-     *
-     * @param string $eventName
-     * @param callable $callBack
-     * @param int $priority
-     * @return void
-     */
-    public function once($eventName, callable $callBack, $priority = 100) {
-
-        $wrapper = null;
-        $wrapper = function() use ($eventName, $callBack, &$wrapper) {
-
-            $this->removeListener($eventName, $wrapper);
-            $result = call_user_func_array($callBack, func_get_args());
-
-        };
-
-        $this->on($eventName, $wrapper);
-
-    }
-
-    /**
-     * Emits an event.
-     *
-     * This method will return true if 0 or more listeners were succesfully
-     * handled. false is returned if one of the events broke the event chain.
-     *
-     * @param string $eventName
-     * @param array $arguments
-     * @return bool
-     */
-    public function emit($eventName, array $arguments = []) {
-
-        foreach($this->listeners($eventName) as $listener) {
-
-            $result = call_user_func_array($listener[1], $arguments);
-            if ($result === false) {
-                return false;
-            }
-        }
-
-        return true;
-
-    }
-
-
-    /**
-     * Returns the list of listeners for an event.
-     *
-     * The list is returned as an array. Every item is another array with 2
-     * elements: priority and the callback.
-     *
-     * The array is returned by reference, and can therefore be used to
-     * manipulate the list of events.
-     *
-     * @param string $eventName
-     * @return array
-     */
-    public function & listeners($eventName) {
-
-        if (!isset($this->listeners[$eventName])) {
-            $this->listeners[$eventName] = [];
-        }
-
-        return $this->listeners[$eventName];
-
-    }
-
-    /**
-     * Removes a specific listener from an event.
-     *
-     * @param string $eventName
-     * @param callable $listener
-     * @return void
-     */
-    public function removeListener($eventName, callable $listener) {
-
-        $listeners =& $this->listeners($eventName);
-        foreach($listeners as $index => $check) {
-            if ($check[1]===$listener) {
-                unset($listeners[$index]);
-                break;
-            }
-        }
-
-    }
-
-    /**
-     * Removes all listeners from the specified event.
-     *
-     * @param string $eventName
-     * @return void
-     */
-    public function removeAllListeners($eventName) {
-
-        $listeners =& $this->listeners($eventName);
-        $listeners = [];
-
-    }
-
-}

sabre-event-1.0.1.tar.gz/lib/Sabre/Event/Version.php Deleted

sabre-event-1.0.1.tar.gz/tests/Sabre Deleted

sabre-event-1.0.1.tar.gz/tests/Sabre/Event Deleted

sabre-event-1.0.1.tar.gz/tests/Sabre/Event/EventEmitterTest.php Deleted

@@ -1,203 +0,0 @@
-<?php
-
-namespace Sabre\Event;
-
-class EventEmitterTest extends \PHPUnit_Framework_TestCase {
-
-    function testInit() {
-
-        $ee = new EventEmitter();
-        $this->assertInstanceOf('Sabre\\Event\\EventEmitter', $ee);
-
-    }
-
-    /**
-     * @depends testInit
-     */
-    function testHandleEvent() {
-
-        $argResult = null;
-
-        $ee = new EventEmitter();
-        $ee->on('foo', function($arg) use (&$argResult) {
-
-            $argResult = $arg;
-
-        });
-
-        $this->assertTrue(
-            $ee->emit('foo', ['bar'])
-        );
-
-        $this->assertEquals('bar', $argResult);
-
-
-    }
-
-    /**
-     * @depends testHandleEvent
-     */
-    function testCancelEvent() {
-
-        $argResult = 0;
-
-        $ee = new EventEmitter();
-        $ee->on('foo', function($arg) use (&$argResult) {
-
-            $argResult = 1;
-            return false;
-
-        });
-        $ee->on('foo', function($arg) use (&$argResult) {
-
-            $argResult = 2;
-
-        });
-
-
-        $this->assertFalse(
-            $ee->emit('foo', ['bar'])
-        );
-
-        $this->assertEquals(1, $argResult);
-
-
-    }
-
-    /**
-     * @depends testCancelEvent
-     */
-    function testPriority() {
-
-        $argResult = 0;
-
-        $ee = new EventEmitter();
-        $ee->on('foo', function($arg) use (&$argResult) {
-
-            $argResult = 1;
-            return false;
-
-        });
-        $ee->on('foo', function($arg) use (&$argResult) {
-
-            $argResult = 2;
-            return false;
-
-        }, 1);
-
-
-        $this->assertFalse(
-            $ee->emit('foo', ['bar'])
-        );
-
-        $this->assertEquals(2, $argResult);
-
-    }
-
-    /**
-     * @depends testPriority
-     */
-    function testPriority2() {
-
-        $result = [];
-        $ee = new EventEmitter();
-
-        $ee->on('foo', function() use (&$result) {
-
-            $result[] = 'a';
-
-        }, 200);
-        $ee->on('foo', function() use (&$result) {
-
-            $result[] = 'b';
-
-        }, 50);
-        $ee->on('foo', function() use (&$result) {
-
-            $result[] = 'c';
-
-        }, 300);
-        $ee->on('foo', function() use (&$result) {
-
-            $result[] = 'd';
-
-        });
-
-        $ee->emit('foo');
-        $this->assertEquals(['b','d','a','c'], $result);
-
-    }
-
-    function testRemoveListener() {
-
-        $result = false;
-
-        $callBack = function() use (&$result) {
-
-            $result = true;
-
-        };
-
-
-        $ee = new EventEmitter();
-
-        $ee->on('foo', $callBack);
-
-        $ee->emit('foo');
-        $this->assertTrue($result);
-        $result = false;
-
-        $ee->removeListener('foo', $callBack);
-
-        $ee->emit('foo');
-        $this->assertFalse($result);
-
-    }
-
-    function testRemoveAllListeners() {
-
-        $result = false;
-
-        $callBack = function() use (&$result) {
-
-            $result = true;
-
-        };
-
-
-        $ee = new EventEmitter();
-
-        $ee->on('foo', $callBack);
-
-        $ee->emit('foo');
-        $this->assertTrue($result);
-        $result = false;
-
-        $ee->removeAllListeners('foo');
-
-        $ee->emit('foo');
-        $this->assertFalse($result);
-
-    }
-
-    function testOnce() {
-
-        $result = 0;
-
-        $callBack = function() use (&$result) {
-
-            $result++;
-
-        };
-
-        $ee = new EventEmitter();
-        $ee->once('foo', $callBack);
-
-        $ee->emit('foo');
-        $ee->emit('foo');
-
-        $this->assertEquals(1, $result);
-
-    }
-
-}

sabre-event-1.0.1.tar.gz/tests/bootstrap.php Deleted

sabre-event-1.0.1.tar.gz/tests/phpunit.xml Deleted

sabre-event-1.0.1.tar.gz/.gitignore -> sabre-event-2.0.2.tar.gz/.gitignore Changed

sabre-event-1.0.1.tar.gz/.travis.yml -> sabre-event-2.0.2.tar.gz/.travis.yml Changed

sabre-event-2.0.2.tar.gz/CHANGELOG.md Added

@@ -0,0 +1,51 @@
+ChangeLog
+=========
+
+2.0.2 (2015-05-19)
+------------------
+
+* This release has no functional changes. It's just been brought up to date
+  with the latest coding standards.
+
+
+2.0.1 (2014-10-06)
+------------------
+
+* Fixed: `$priority` was ignored in `EventEmitter::once` method.
+* Fixed: Breaking the event chain was not possible in `EventEmitter::once`.
+
+
+2.0.0 (2014-06-21)
+------------------
+
+* Added: When calling emit, it's now possible to specify a callback that will be
+  triggered after each method handled. This is dubbed the 'continueCallback' and
+  can be used to implement strategy patterns.
+* Added: Promise object!
+* Changed: EventEmitter::listeners now returns just the callbacks for an event,
+  and no longer returns the list by reference. The list is now automatically
+  sorted by priority.
+* Update: Speed improvements.
+* Updated: It's now possible to remove all listeners for every event.
+* Changed: Now uses psr-4 autoloading.
+
+
+1.0.1 (2014-06-12)
+------------------
+
+* hhvm compatible!
+* Fixed: Issue #4. Compatiblitiy for PHP < 5.4.14.
+
+
+1.0.0 (2013-07-19)
+------------------
+
+* Added: removeListener, removeAllListeners
+* Added: once, to only listen to an event emitting once.
+* Added README.md.
+
+
+0.0.1-alpha (2013-06-29)
+------------------------
+
+* First version!

sabre-event-1.0.1.tar.gz/LICENSE -> sabre-event-2.0.2.tar.gz/LICENSE Changed

sabre-event-1.0.1.tar.gz/README.md -> sabre-event-2.0.2.tar.gz/README.md Changed

@@ -1,172 +1,35 @@
 sabre/event
 ===========
 
-A lightweight library for event management in PHP.
+A lightweight library for event-based development in PHP.
 
-It's design is inspired by Node.js's [EventEmitter][1]. sabre/event requires
-PHP 5.4.
+This library provides two patterns:
 
-It's distinct from [Événement][2], because I needed a couple of features that
-were in conflict with it's design goals. Namely: prioritization, and the
-ability to stop the event chain, like javascript's `preventDefault`.
+1. EventEmitter
+2. Promises
+
+Full documentation can be found on [the website][1].
 
 Installation
 ------------
 
-Make sure you have [composer][3] installed. In your project directory, create,
-or edit a `composer.json` file, and make sure it contains something like this:
-
-
-```json
-{
-    "require" : {
-        "sabre/event" : "~0.0.1@alpha"
-    }
-}
-```
-
-After that, just hit `composer install` and you should be rolling.
-
-Usage
------
-
-In an event system there are emitters, and listeners. Emitters trigger an
-event, at which point a listener is notified.
-
-Example:
-
-```php
-use Sabre\Event\EventEmitter;
-
-include 'vendor/autoload.php';
-
-$eventEmitter = new EventEmitter();
-
-// subscribing
-$eventEmitter->on('create', function() {
-
-    echo "Something got created, apparently\n"
-
-});
-
-$eventEmitter->emit('create');
-```
-
-The name of the event (`create`) can be any free-form string.
-
-### Priorities
-
-By supplying a priority, you can make sure that subscribers are handled in a
-specific order. The default priority is 100. Anything below that will be
-triggered earlier, anything higher later.
-
-If there's two subscribers with the same priority, they will execute in an
-undefined, but deterministic order.
-
-```php
-$eventEmitter->on('create', function() {
-
-// This event will be handled first.
-
-}, 50);
-```
-
-### Callbacks
-
-All default PHP callbacks are supported, so closures are not required.
-
-```php
-$eventEmitter->on('create', 'myFunction');
-$eventEmitter->on('create', ['myClass', 'myMethod']);
-$eventEmitter->on('create', [$myInstance, 'myMethod']);
-```
-
-### Canceling the event handler.
-
-If a callback returns `false` the event chain is stopped immidiately.
-
-A usecase is to use a listener to check if a user has permission to perform
-a certain action, and stop execution if they don't.
+Make sure you have [composer][3] installed, and then run:
 
-```php
-$eventEmitter->on('create', function() {
+    composer require sabre/event "~2.0.0"
 
-    if (!checkPermission()) {
-        return false;
-    }
+For legacy reasons, we also provide a unsupported [PHP 5.3 compatible version][6].
+We recommend that you update your servers and use the regular version instead, though.
 
-}, 10);
-```
-
-`EventEmitter::emit()` will return `false` if the event was cancelled, and
-true if it wasn't.
-
-SabreDAV uses this feature heavily as well. When a HTTP request is received
-various plugins see if they are capable of handling the request. If they
-do, they can return false so other plugins will not also attempt to handle
-the request.
-
-Throwing an exception will also stop the chain.
-
-### Passing arguments
-
-Arguments can be passed as an array.
-
-```php
-$eventEmitter->on('create', function($entityId) {
-
-    echo "An entity with id ", $entityId, " just got created.\n";
-
-});
-
-$entityId = 5;
-$eventEmitter->emit('create', [$entityId]);
-```
-
-Because you cannot really do anything with the return value of a listener,
-you can pass arguments by reference to communicate between listeners and
-back to the emitter.
-
-```php
-$eventEmitter->on('create', function($entityId, &$warnings) {
-
-    echo "An entity with id ", $entityId, " just got created.\n";
-
-    $warnings[] = "Something bad may or may not have happened.\n";
-
-});
-
-
-$warnings = [];
-$eventEmitter->emit('create', [$entityId, &$warnings]);
-
-print_r($warnings);
-```
-
-
-### Integration into other objects.
-
-To add `EventEmitter` capabilities to any class, you can simply extend it.
-
-If you cannot extend, because the class is already part of an existing class
-hierarchy you can use the supplied trait.
-
-```php
-use Sabre\Event;
-
-
-class MyNotUneventfulApplication
-    extends AppController
-    implements Event\EventEmitterInterface
-{
-
-    use Event\EventEmitterTrait();
+Build status
+------------
 
-}
-```
+| branch | status |
+| ------ | ------ |
+| master | [![Build Status](https://travis-ci.org/fruux/sabre-event.svg?branch=master)](https://travis-ci.org/fruux/sabre-event) |
+| 2.0    | [![Build Status](https://travis-ci.org/fruux/sabre-event.svg?branch=2.0)](https://travis-ci.org/fruux/sabre-event) |
+| 1.0    | [![Build Status](https://travis-ci.org/fruux/sabre-event.svg?branch=1.0)](https://travis-ci.org/fruux/sabre-event) |
+| php53  | [![Build Status](https://travis-ci.org/fruux/sabre-event.svg?branch=php53)](https://travis-ci.org/fruux/sabre-event) |
 
-In the preceeding example, `MyNotUneventfulApplication` has all the
-capabilities of `EventEmitter`.
 
 Questions?
 ----------
@@ -179,8 +42,8 @@
 
 This library is being developed by [fruux](https://fruux.com/). Drop us a line for commercial services or enterprise support.
 
-[1]: http://nodejs.org/api/events.html
-[2]: https://github.com/igorw/evenement
+[1]: http://sabre.io/event/
 [3]: http://getcomposer.org/
 [4]: http://groups.google.com/group/sabredav-discuss
 [5]: https://github.com/fruux/sabre-event/issues/
+[6]: https://github.com/fruux/sabre-event/tree/php53

sabre-event-2.0.2.tar.gz/bin Added

sabre-event-2.0.2.tar.gz/bin/.empty Added

sabre-event-1.0.1.tar.gz/composer.json -> sabre-event-2.0.2.tar.gz/composer.json Changed

@@ -1,27 +1,41 @@
 {
     "name": "sabre/event",
-    "description" : "The sabre/event library provides utilities for lightweight event-based programming",
-    "keywords" : [ "Events", "EventEmitter" ],
-    "homepage" : "http://sabre.io/event",
-    "license" : "BSD-3-Clause",
-    "require" : {
-        "php"          : ">=5.4.1"
+    "description": "sabre/event is a library for lightweight event-based programming",
+    "keywords": [
+        "Events",
+        "EventEmitter",
+        "Promise",
+        "Hooks",
+        "Plugin",
+        "Signal"
+    ],
+    "homepage": "http://sabre.io/event/",
+    "license": "BSD-3-Clause",
+    "require": {
+        "php": ">=5.4.1"
     },
-    "authors" : [
+    "authors": [
         {
-            "name" : "Evert Pot",
-            "email" : "me@evertpot.com",
-            "homepage" : "http://evertpot.com/",
-            "role" : "Developer"
+            "name": "Evert Pot",
+            "email": "me@evertpot.com",
+            "homepage": "http://evertpot.com/",
+            "role": "Developer"
         }
     ],
-    "support" : {
-        "forum" : "https://groups.google.com/group/sabredav-discuss",
-        "source" : "https://github.com/fruux/sabre-event"
+    "support": {
+        "forum": "https://groups.google.com/group/sabredav-discuss",
+        "source": "https://github.com/fruux/sabre-event"
     },
-    "autoload" : {
-        "psr-0" : {
-            "Sabre\\Event" : "lib/"
+    "autoload": {
+        "psr-4": {
+            "Sabre\\Event\\": "lib/"
         }
+    },
+    "require-dev": {
+        "sabre/cs": "~0.0.1",
+        "phpunit/phpunit" : "*"
+    },
+    "config" : {
+        "bin-dir" : "bin/"
     }
 }

sabre-event-2.0.2.tar.gz/lib/EventEmitter.php Added

sabre-event-2.0.2.tar.gz/lib/EventEmitterInterface.php Added

@@ -0,0 +1,100 @@
+<?php
+
+namespace Sabre\Event;
+
+/**
+ * Event Emitter Interface
+ *
+ * Anything that accepts listeners and emits events should implement this
+ * interface.
+ *
+ * @copyright Copyright (C) 2013-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+interface EventEmitterInterface {
+
+    /**
+     * Subscribe to an event.
+     *
+     * @param string $eventName
+     * @param callable $callBack
+     * @param int $priority
+     * @return void
+     */
+    function on($eventName, callable $callBack, $priority = 100);
+
+    /**
+     * Subscribe to an event exactly once.
+     *
+     * @param string $eventName
+     * @param callable $callBack
+     * @param int $priority
+     * @return void
+     */
+    function once($eventName, callable $callBack, $priority = 100);
+
+    /**
+     * Emits an event.
+     *
+     * This method will return true if 0 or more listeners were succesfully
+     * handled. false is returned if one of the events broke the event chain.
+     *
+     * If the continueCallBack is specified, this callback will be called every
+     * time before the next event handler is called.
+     *
+     * If the continueCallback returns false, event propagation stops. This
+     * allows you to use the eventEmitter as a means for listeners to implement
+     * functionality in your application, and break the event loop as soon as
+     * some condition is fulfilled.
+     *
+     * Note that returning false from an event subscriber breaks propagation
+     * and returns false, but if the continue-callback stops propagation, this
+     * is still considered a 'successful' operation and returns true.
+     *
+     * Lastly, if there are 5 event handlers for an event. The continueCallback
+     * will be called at most 4 times.
+     *
+     * @param string $eventName
+     * @param array $arguments
+     * @param callback $continueCallBack
+     * @return bool
+     */
+    function emit($eventName, array $arguments = [], callable $continueCallBack = null);
+
+    /**
+     * Returns the list of listeners for an event.
+     *
+     * The list is returned as an array, and the list of events are sorted by
+     * their priority.
+     *
+     * @param string $eventName
+     * @return callable[]
+     */
+    function listeners($eventName);
+
+    /**
+     * Removes a specific listener from an event.
+     *
+     * If the listener could not be found, this method will return false. If it
+     * was removed it will return true.
+     *
+     * @param string $eventName
+     * @param callable $listener
+     * @return bool
+     */
+    function removeListener($eventName, callable $listener);
+
+    /**
+     * Removes all listeners.
+     *
+     * If the eventName argument is specified, all listeners for that event are
+     * removed. If it is not specified, every listener for every event is
+     * removed.
+     *
+     * @param string $eventName
+     * @return void
+     */
+    function removeAllListeners($eventName = null);
+
+}

sabre-event-2.0.2.tar.gz/lib/EventEmitterTrait.php Added

@@ -0,0 +1,211 @@
+<?php
+
+namespace Sabre\Event;
+
+/**
+ * Event Emitter Trait
+ *
+ * This trait contains all the basic functions to implement an
+ * EventEmitterInterface.
+ *
+ * Using the trait + interface allows you to add EventEmitter capabilities
+ * without having to change your base-class.
+ *
+ * @copyright Copyright (C) 2013-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+trait EventEmitterTrait {
+
+    /**
+     * The list of listeners
+     *
+     * @var array
+     */
+    protected $listeners = [];
+
+    /**
+     * Subscribe to an event.
+     *
+     * @param string $eventName
+     * @param callable $callBack
+     * @param int $priority
+     * @return void
+     */
+    function on($eventName, callable $callBack, $priority = 100) {
+
+        if (!isset($this->listeners[$eventName])) {
+            $this->listeners[$eventName] = [
+                true,  // If there's only one item, it's sorted
+                [$priority],
+                [$callBack]
+            ];
+        } else {
+            $this->listeners[$eventName][0] = false; // marked as unsorted
+            $this->listeners[$eventName][1][] = $priority;
+            $this->listeners[$eventName][2][] = $callBack;
+        }
+
+    }
+
+    /**
+     * Subscribe to an event exactly once.
+     *
+     * @param string $eventName
+     * @param callable $callBack
+     * @param int $priority
+     * @return void
+     */
+    function once($eventName, callable $callBack, $priority = 100) {
+
+        $wrapper = null;
+        $wrapper = function() use ($eventName, $callBack, &$wrapper) {
+
+            $this->removeListener($eventName, $wrapper);
+            return call_user_func_array($callBack, func_get_args());
+
+        };
+
+        $this->on($eventName, $wrapper, $priority);
+
+    }
+
+    /**
+     * Emits an event.
+     *
+     * This method will return true if 0 or more listeners were succesfully
+     * handled. false is returned if one of the events broke the event chain.
+     *
+     * If the continueCallBack is specified, this callback will be called every
+     * time before the next event handler is called.
+     *
+     * If the continueCallback returns false, event propagation stops. This
+     * allows you to use the eventEmitter as a means for listeners to implement
+     * functionality in your application, and break the event loop as soon as
+     * some condition is fulfilled.
+     *
+     * Note that returning false from an event subscriber breaks propagation
+     * and returns false, but if the continue-callback stops propagation, this
+     * is still considered a 'successful' operation and returns true.
+     *
+     * Lastly, if there are 5 event handlers for an event. The continueCallback
+     * will be called at most 4 times.
+     *
+     * @param string $eventName
+     * @param array $arguments
+     * @param callback $continueCallBack
+     * @return bool
+     */
+    function emit($eventName, array $arguments = [], callable $continueCallBack = null) {
+
+        if (is_null($continueCallBack)) {
+
+            foreach ($this->listeners($eventName) as $listener) {
+
+                $result = call_user_func_array($listener, $arguments);
+                if ($result === false) {
+                    return false;
+                }
+            }
+
+        } else {
+
+            $listeners = $this->listeners($eventName);
+            $counter = count($listeners);
+
+            foreach ($listeners as $listener) {
+
+                $counter--;
+                $result = call_user_func_array($listener, $arguments);
+                if ($result === false) {
+                    return false;
+                }
+
+                if ($counter > 0) {
+                    if (!$continueCallBack()) break;
+                }
+
+            }
+
+        }
+
+        return true;
+
+    }
+
+    /**
+     * Returns the list of listeners for an event.
+     *
+     * The list is returned as an array, and the list of events are sorted by
+     * their priority.
+     *
+     * @param string $eventName
+     * @return callable[]
+     */
+    function listeners($eventName) {
+
+        if (!isset($this->listeners[$eventName])) {
+            return [];
+        }
+
+        // The list is not sorted
+        if (!$this->listeners[$eventName][0]) {
+
+            // Sorting
+            array_multisort($this->listeners[$eventName][1], SORT_NUMERIC, $this->listeners[$eventName][2]);
+
+            // Marking the listeners as sorted
+            $this->listeners[$eventName][0] = true;
+        }
+
+        return $this->listeners[$eventName][2];
+
+    }
+
+    /**
+     * Removes a specific listener from an event.
+     *
+     * If the listener could not be found, this method will return false. If it
+     * was removed it will return true.
+     *
+     * @param string $eventName
+     * @param callable $listener
+     * @return bool
+     */
+    function removeListener($eventName, callable $listener) {
+
+        if (!isset($this->listeners[$eventName])) {
+            return false;
+        }
+        foreach ($this->listeners[$eventName][2] as $index => $check) {
+            if ($check === $listener) {
+                unset($this->listeners[$eventName][1][$index]);
+                unset($this->listeners[$eventName][2][$index]);
+                return true;
+            }
+        }
+        return false;
+
+    }
+
+    /**
+     * Removes all listeners.
+     *
+     * If the eventName argument is specified, all listeners for that event are
+     * removed. If it is not specified, every listener for every event is
+     * removed.
+     *
+     * @param string $eventName
+     * @return void
+     */
+    function removeAllListeners($eventName = null) {
+
+        if (!is_null($eventName)) {
+            unset($this->listeners[$eventName]);
+        } else {
+            $this->listeners = [];
+        }
+
+    }
+
+}

sabre-event-2.0.2.tar.gz/lib/Promise.php Added

@@ -0,0 +1,243 @@
+<?php
+
+namespace Sabre\Event;
+
+use Exception;
+
+/**
+ * An implementation of the Promise pattern.
+ *
+ * Promises basically allow you to avoid what is commonly called 'callback
+ * hell'. It allows for easily chaining of asynchronous operations.
+ *
+ * @copyright Copyright (C) 2013-2015 fruux GmbH (https://fruux.com/).
+ * @author Evert Pot (http://evertpot.com/)
+ * @license http://sabre.io/license/ Modified BSD License
+ */
+class Promise {
+
+    /**
+     * Pending promise. No result yet.
+     */
+    const PENDING = 0;
+
+    /**
+     * The promise has been fulfilled. It was successful.
+     */
+    const FULFILLED = 1;
+
+    /**
+     * The promise was rejected. The operation failed.
+     */
+    const REJECTED = 2;
+
+    /**
+     * The current state of this promise.
+     *
+     * @var int
+     */
+    protected $state = self::PENDING;
+
+    /**
+     * A list of subscribers. Subscribers are the callbacks that want us to let
+     * them know if the callback was fulfilled or rejected.
+     *
+     * @var array
+     */
+    protected $subscribers = [];
+
+    /**
+     * The result of the promise.
+     *
+     * If the promise was fulfilled, this will be the result value. If the
+     * promise was rejected, this is most commonly an exception.
+     *
+     * @var mixed
+     */
+    protected $value = null;
+
+    /**
+     * Creates the promise.
+     *
+     * The passed argument is the executor. The executor is automatically
+     * called with two arguments.
+     *
+     * Each are callbacks that map to $this->fulfill and $this->reject.
+     * Using the executor is optional.
+     *
+     * @param callable $executor
+     */
+    function __construct(callable $executor = null) {
+
+        if ($executor) {
+            $executor(
+                [$this, 'fulfill'],
+                [$this, 'reject']
+            );
+        }
+
+    }
+
+    /**
+     * This method allows you to specify the callback that will be called after
+     * the promise has been fulfilled or rejected.
+     *
+     * Both arguments are optional.
+     *
+     * This method returns a new promise, which can be used for chaining.
+     * If either the onFulfilled or onRejected callback is called, you may
+     * return a result from this callback.
+     *
+     * If the result of this callback is yet another promise, the result of
+     * _that_ promise will be used to set the result of the returned promise.
+     *
+     * If either of the callbacks return any other value, the returned promise
+     * is automatically fulfilled with that value.
+     *
+     * If either of the callbacks throw an exception, the returned promise will
+     * be rejected and the exception will be passed back.
+     *
+     * @param callable $onFulfilled
+     * @param callable $onRejected
+     * @return Promise
+     */
+    function then(callable $onFulfilled = null, callable $onRejected = null) {
+
+        $subPromise = new self();
+        switch ($this->state) {
+            case self::PENDING :
+                $this->subscribers[] = [$subPromise, $onFulfilled, $onRejected];
+                break;
+            case self::FULFILLED :
+                $this->invokeCallback($subPromise, $onFulfilled);
+                break;
+            case self::REJECTED :
+                $this->invokeCallback($subPromise, $onRejected);
+                break;
+        }
+        return $subPromise;
+
+    }
+
+    /**
+     * Add a callback for when this promise is rejected.
+     *
+     * I would have used the word 'catch', but it's a reserved word in PHP, so
+     * we're not allowed to call our function that.
+     *
+     * @param callable $onRejected
+     * @return Promise
+     */
+    function error(callable $onRejected) {
+
+        return $this->then(null, $onRejected);
+
+    }
+
+    /**
+     * Marks this promise as fulfilled and sets its return value.
+     *
+     * @param mixed $value
+     * @return void
+     */
+    function fulfill($value = null) {
+        if ($this->state !== self::PENDING) {
+            throw new PromiseAlreadyResolvedException('This promise is already resolved, and you\'re not allowed to resolve a promise more than once');
+        }
+        $this->state = self::FULFILLED;
+        $this->value = $value;
+        foreach ($this->subscribers as $subscriber) {
+            $this->invokeCallback($subscriber[0], $subscriber[1]);
+        }
+    }
+
+    /**
+     * Marks this promise as rejected, and set it's rejection reason.
+     *
+     * @param mixed $reason
+     * @return void
+     */
+    function reject($reason = null) {
+        if ($this->state !== self::PENDING) {
+            throw new PromiseAlreadyResolvedException('This promise is already resolved, and you\'re not allowed to resolve a promise more than once');
+        }
+        $this->state = self::REJECTED;
+        $this->value = $reason;
+        foreach ($this->subscribers as $subscriber) {
+            $this->invokeCallback($subscriber[0], $subscriber[2]);
+        }
+
+    }
+
+    /**
+     * It's possible to send an array of promises to the all method. This
+     * method returns a promise that will be fulfilled, only if all the passed
+     * promises are fulfilled.
+     *
+     * @param Promise[] $promises
+     * @return Promise
+     */
+    static function all(array $promises) {
+
+        return new self(function($success, $fail) use ($promises) {
+
+            $successCount = 0;
+            $completeResult = [];
+
+            foreach ($promises as $promiseIndex => $subPromise) {
+
+                $subPromise->then(
+                    function($result) use ($promiseIndex, &$completeResult, &$successCount, $success, $promises) {
+                        $completeResult[$promiseIndex] = $result;
+                        $successCount++;
+                        if ($successCount === count($promises)) {
+                            $success($completeResult);
+                        }
+                        return $result;
+                    }
+                )->error(
+                    function($reason) use ($fail) {
+                        $fail($reason);
+                    }
+                );
+
+            }
+        });
+
+    }
+
+    /**
+     * This method is used to call either an onFulfilled or onRejected callback.
+     *
+     * This method makes sure that the result of these callbacks are handled
+     * correctly, and any chained promises are also correctly fulfilled or
+     * rejected.
+     *
+     * @param Promise $subPromise
+     * @param callable $callBack
+     * @return void
+     */
+    protected function invokeCallback(Promise $subPromise, callable $callBack = null) {
+
+        if (is_callable($callBack)) {
+            try {
+                $result = $callBack($this->value);
+                if ($result instanceof self) {
+                    $result->then([$subPromise, 'fulfill'], [$subPromise, 'reject']);
+                } else {
+                    $subPromise->fulfill($result);
+                }
+            } catch (Exception $e) {
+                $subPromise->reject($e);
+            }
+        } else {
+            if ($this->state === self::FULFILLED) {
+                $subPromise->fulfill($this->value);
+            } else {
+                $subPromise->reject($this->value);
+            }
+        }
+    }
+
+
+}

sabre-event-2.0.2.tar.gz/lib/PromiseAlreadyResolvedException.php Added

sabre-event-2.0.2.tar.gz/lib/Version.php Added

sabre-event-2.0.2.tar.gz/phpunit.xml.dist Added

sabre-event-2.0.2.tar.gz/tests/ContinueCallbackTest.php Added

@@ -0,0 +1,76 @@
+<?php
+
+namespace Sabre\Event;
+
+class ContinueCallbackTest extends \PHPUnit_Framework_TestCase {
+
+    function testContinueCallBack() {
+
+        $ee = new EventEmitter();
+
+        $handlerCounter = 0;
+        $bla = function() use (&$handlerCounter) {
+            $handlerCounter++;
+        };
+        $ee->on('foo', $bla);
+        $ee->on('foo', $bla);
+        $ee->on('foo', $bla);
+
+        $continueCounter = 0;
+        $r = $ee->emit('foo', [], function() use (&$continueCounter) {
+            $continueCounter++;
+            return true;
+        });
+        $this->assertTrue($r);
+        $this->assertEquals(3, $handlerCounter);
+        $this->assertEquals(2, $continueCounter);
+
+    }
+
+    function testContinueCallBackBreak() {
+
+        $ee = new EventEmitter();
+
+        $handlerCounter = 0;
+        $bla = function() use (&$handlerCounter) {
+            $handlerCounter++;
+        };
+        $ee->on('foo', $bla);
+        $ee->on('foo', $bla);
+        $ee->on('foo', $bla);
+
+        $continueCounter = 0;
+        $r = $ee->emit('foo', [], function() use (&$continueCounter) {
+            $continueCounter++;
+            return false;
+        });
+        $this->assertTrue($r);
+        $this->assertEquals(1, $handlerCounter);
+        $this->assertEquals(1, $continueCounter);
+
+    }
+
+    function testContinueCallBackBreakByHandler() {
+
+        $ee = new EventEmitter();
+
+        $handlerCounter = 0;
+        $bla = function() use (&$handlerCounter) {
+            $handlerCounter++;
+            return false;
+        };
+        $ee->on('foo', $bla);
+        $ee->on('foo', $bla);
+        $ee->on('foo', $bla);
+
+        $continueCounter = 0;
+        $r = $ee->emit('foo', [], function() use (&$continueCounter) {
+            $continueCounter++;
+            return false;
+        });
+        $this->assertFalse($r);
+        $this->assertEquals(1, $handlerCounter);
+        $this->assertEquals(0, $continueCounter);
+
+    }
+}

sabre-event-2.0.2.tar.gz/tests/EventEmitterTest.php Added

@@ -0,0 +1,318 @@
+<?php
+
+namespace Sabre\Event;
+
+class EventEmitterTest extends \PHPUnit_Framework_TestCase {
+
+    function testInit() {
+
+        $ee = new EventEmitter();
+        $this->assertInstanceOf('Sabre\\Event\\EventEmitter', $ee);
+
+    }
+
+    function testListeners() {
+
+        $ee = new EventEmitter();
+
+        $callback1 = function() { };
+        $callback2 = function() { };
+        $ee->on('foo', $callback1, 200);
+        $ee->on('foo', $callback2, 100);
+
+        $this->assertEquals([$callback2, $callback1], $ee->listeners('foo'));
+
+    }
+
+    /**
+     * @depends testInit
+     */
+    function testHandleEvent() {
+
+        $argResult = null;
+
+        $ee = new EventEmitter();
+        $ee->on('foo', function($arg) use (&$argResult) {
+
+            $argResult = $arg;
+
+        });
+
+        $this->assertTrue(
+            $ee->emit('foo', ['bar'])
+        );
+
+        $this->assertEquals('bar', $argResult);
+
+    }
+
+    /**
+     * @depends testHandleEvent
+     */
+    function testCancelEvent() {
+
+        $argResult = 0;
+
+        $ee = new EventEmitter();
+        $ee->on('foo', function($arg) use (&$argResult) {
+
+            $argResult = 1;
+            return false;
+
+        });
+        $ee->on('foo', function($arg) use (&$argResult) {
+
+            $argResult = 2;
+
+        });
+
+        $this->assertFalse(
+            $ee->emit('foo', ['bar'])
+        );
+
+        $this->assertEquals(1, $argResult);
+
+    }
+
+    /**
+     * @depends testCancelEvent
+     */
+    function testPriority() {
+
+        $argResult = 0;
+
+        $ee = new EventEmitter();
+        $ee->on('foo', function($arg) use (&$argResult) {
+
+            $argResult = 1;
+            return false;
+
+        });
+        $ee->on('foo', function($arg) use (&$argResult) {
+
+            $argResult = 2;
+            return false;
+
+        }, 1);
+
+        $this->assertFalse(
+            $ee->emit('foo', ['bar'])
+        );
+
+        $this->assertEquals(2, $argResult);
+
+    }
+
+    /**
+     * @depends testPriority
+     */
+    function testPriority2() {
+
+        $result = [];
+        $ee = new EventEmitter();
+
+        $ee->on('foo', function() use (&$result) {
+
+            $result[] = 'a';
+
+        }, 200);
+        $ee->on('foo', function() use (&$result) {
+
+            $result[] = 'b';
+
+        }, 50);
+        $ee->on('foo', function() use (&$result) {
+
+            $result[] = 'c';
+
+        }, 300);
+        $ee->on('foo', function() use (&$result) {
+
+            $result[] = 'd';
+
+        });
+
+        $ee->emit('foo');
+        $this->assertEquals(['b', 'd', 'a', 'c'], $result);
+
+    }
+
+    function testRemoveListener() {
+
+        $result = false;
+
+        $callBack = function() use (&$result) {
+
+            $result = true;
+
+        };
+
+        $ee = new EventEmitter();
+
+        $ee->on('foo', $callBack);
+
+        $ee->emit('foo');
+        $this->assertTrue($result);
+        $result = false;
+
+        $this->assertTrue(
+            $ee->removeListener('foo', $callBack)
+        );
+
+        $ee->emit('foo');
+        $this->assertFalse($result);
+
+    }
+
+    function testRemoveUnknownListener() {
+
+        $result = false;
+
+        $callBack = function() use (&$result) {
+
+            $result = true;
+
+        };
+
+        $ee = new EventEmitter();
+
+        $ee->on('foo', $callBack);
+
+        $ee->emit('foo');
+        $this->assertTrue($result);
+        $result = false;
+
+        $this->assertFalse($ee->removeListener('bar', $callBack));
+
+        $ee->emit('foo');
+        $this->assertTrue($result);
+
+    }
+
+    function testRemoveListenerTwice() {
+
+        $result = false;
+
+        $callBack = function() use (&$result) {
+
+            $result = true;
+
+        };
+
+        $ee = new EventEmitter();
+
+        $ee->on('foo', $callBack);
+
+        $ee->emit('foo');
+        $this->assertTrue($result);
+        $result = false;
+
+        $this->assertTrue(
+            $ee->removeListener('foo', $callBack)
+        );
+        $this->assertFalse(
+            $ee->removeListener('foo', $callBack)
+        );
+
+        $ee->emit('foo');
+        $this->assertFalse($result);
+
+    }
+
+    function testRemoveAllListeners() {
+
+        $result = false;
+        $callBack = function() use (&$result) {
+
+            $result = true;
+
+        };
+
+        $ee = new EventEmitter();
+        $ee->on('foo', $callBack);
+
+        $ee->emit('foo');
+        $this->assertTrue($result);
+        $result = false;
+
+        $ee->removeAllListeners('foo');
+
+        $ee->emit('foo');
+        $this->assertFalse($result);
+
+    }
+
+    function testRemoveAllListenersNoArg() {
+
+        $result = false;
+
+        $callBack = function() use (&$result) {
+
+            $result = true;
+
+        };
+
+
+        $ee = new EventEmitter();
+        $ee->on('foo', $callBack);
+
+        $ee->emit('foo');
+        $this->assertTrue($result);
+        $result = false;
+
+        $ee->removeAllListeners();
+
+        $ee->emit('foo');
+        $this->assertFalse($result);
+
+    }
+
+    function testOnce() {
+
+        $result = 0;
+
+        $callBack = function() use (&$result) {
+
+            $result++;
+
+        };
+
+        $ee = new EventEmitter();
+        $ee->once('foo', $callBack);
+
+        $ee->emit('foo');
+        $ee->emit('foo');
+
+        $this->assertEquals(1, $result);
+
+    }
+
+    /**
+     * @depends testCancelEvent
+     */
+    function testPriorityOnce() {
+
+        $argResult = 0;
+
+        $ee = new EventEmitter();
+        $ee->once('foo', function($arg) use (&$argResult) {
+
+            $argResult = 1;
+            return false;
+
+        });
+        $ee->once('foo', function($arg) use (&$argResult) {
+
+            $argResult = 2;
+            return false;
+
+        }, 1);
+
+        $this->assertFalse(
+            $ee->emit('foo', ['bar'])
+        );
+
+        $this->assertEquals(2, $argResult);
+
+    }
+}

sabre-event-2.0.2.tar.gz/tests/PromiseTest.php Added

@@ -0,0 +1,226 @@
+<?php
+
+namespace Sabre\Event;
+
+class PromiseTest extends \PHPUnit_Framework_TestCase {
+
+    function testSuccess() {
+
+        $finalValue = 0;
+        $promise = new Promise();
+        $promise->fulfill(1);
+
+        $promise->then(function($value) use (&$finalValue) {
+            $finalValue = $value + 2;
+        });
+
+        $this->assertEquals(3, $finalValue);
+
+    }
+
+    function testFail() {
+
+        $finalValue = 0;
+        $promise = new Promise();
+        $promise->reject(1);
+
+        $promise->then(null, function($value) use (&$finalValue) {
+            $finalValue = $value + 2;
+        });
+
+        $this->assertEquals(3, $finalValue);
+
+    }
+
+    function testChain() {
+
+        $finalValue = 0;
+        $promise = new Promise();
+        $promise->fulfill(1);
+
+        $promise->then(function($value) use (&$finalValue) {
+            $finalValue = $value + 2;
+            return $finalValue;
+        })->then(function($value) use (&$finalValue) {
+            $finalValue = $value + 4;
+            return $finalValue;
+        });
+
+        $this->assertEquals(7, $finalValue);
+
+    }
+    function testChainPromise() {
+
+        $finalValue = 0;
+        $promise = new Promise();
+        $promise->fulfill(1);
+
+        $subPromise = new Promise();
+
+        $promise->then(function($value) use ($subPromise) {
+            return $subPromise;
+        })->then(function($value) use (&$finalValue) {
+            $finalValue = $value + 4;
+            return $finalValue;
+        });
+
+        $subPromise->fulfill(2);
+
+        $this->assertEquals(6, $finalValue);
+
+    }
+
+    function testPendingResult() {
+
+        $finalValue = 0;
+        $promise = new Promise();
+
+        $promise->then(function($value) use (&$finalValue) {
+            $finalValue = $value + 2;
+        });
+
+        $promise->fulfill(4);
+        $this->assertEquals(6, $finalValue);
+
+    }
+
+    function testPendingFail() {
+
+        $finalValue = 0;
+        $promise = new Promise();
+
+        $promise->then(null, function($value) use (&$finalValue) {
+            $finalValue = $value + 2;
+        });
+
+        $promise->reject(4);
+        $this->assertEquals(6, $finalValue);
+
+    }
+
+    function testExecutorSuccess() {
+
+        $promise = (new Promise(function($success, $fail) {
+
+            $success('hi');
+
+        }))->then(function($result) use (&$realResult) {
+
+            $realResult = $result;
+
+        });
+
+        $this->assertEquals('hi', $realResult);
+
+    }
+
+    function testExecutorFail() {
+
+        $promise = (new Promise(function($success, $fail) {
+
+            $fail('hi');
+
+        }))->then(function($result) use (&$realResult) {
+
+            $realResult = 'incorrect';
+
+        }, function($reason) use (&$realResult) {
+
+            $realResult = $reason;
+
+        });
+
+        $this->assertEquals('hi', $realResult);
+
+    }
+
+    /**
+     * @expectedException \Sabre\Event\PromiseAlreadyResolvedException
+     */
+    function testFulfillTwice() {
+
+        $promise = new Promise();
+        $promise->fulfill(1);
+        $promise->fulfill(1);
+
+    }
+
+    /**
+     * @expectedException \Sabre\Event\PromiseAlreadyResolvedException
+     */
+    function testRejectTwice() {
+
+        $promise = new Promise();
+        $promise->reject(1);
+        $promise->reject(1);
+
+    }
+
+    function testFromFailureHandler() {
+
+        $ok = 0;
+        $promise = new Promise();
+        $promise->error(function($reason) {
+
+            $this->assertEquals('foo', $reason);
+            throw new \Exception('hi');
+
+        })->then(function() use (&$ok) {
+
+            $ok = -1;
+
+        }, function() use (&$ok) {
+
+            $ok = 1;
+
+        });
+
+        $this->assertEquals(0, $ok);
+        $promise->reject('foo');
+        $this->assertEquals(1, $ok);
+
+    }
+
+    function testAll() {
+
+        $promise1 = new Promise();
+        $promise2 = new Promise();
+
+        $finalValue = 0;
+        Promise::all([$promise1, $promise2])->then(function($value) use (&$finalValue) {
+
+            $finalValue = $value;
+
+        });
+
+        $promise1->fulfill(1);
+        $this->assertEquals(0, $finalValue);
+        $promise2->fulfill(2);
+        $this->assertEquals([1, 2], $finalValue);
+
+    }
+
+    function testAllReject() {
+
+        $promise1 = new Promise();
+        $promise2 = new Promise();
+
+        $finalValue = 0;
+        Promise::all([$promise1, $promise2])->then(
+            function($value) use (&$finalValue) {
+                $finalValue = 'foo';
+                return 'test';
+            },
+            function($value) use (&$finalValue) {
+                $finalValue = $value;
+            }
+        );
+
+        $promise1->reject(1);
+        $this->assertEquals(1, $finalValue);
+        $promise2->reject(2);
+        $this->assertEquals(1, $finalValue);
+
+    }
+
+}

sabre-event-2.0.2.tar.gz/tests/benchmark Added

sabre-event-2.0.2.tar.gz/tests/benchmark/bench.php Added

@@ -0,0 +1,116 @@
+<?php
+
+use Sabre\Event\EventEmitter;
+
+include __DIR__ . '/../../vendor/autoload.php';
+
+abstract class BenchMark {
+
+    protected $startTime;
+    protected $iterations = 10000;
+    protected $totalTime;
+
+    function setUp() {
+
+    }
+
+    abstract function test();
+
+    function go() {
+
+        $this->setUp();
+        $this->startTime = microtime(true);
+        $this->test();
+        $this->totalTime = microtime(true) - $this->startTime;
+        return $this->totalTime;
+
+    }
+
+}
+
+class OneCallBack extends BenchMark {
+
+    protected $emitter;
+    protected $iterations = 100000;
+
+    function setUp() {
+
+        $this->emitter = new EventEmitter();
+        $this->emitter->on('foo', function() {
+            // NOOP
+        });
+
+    }
+
+    function test() {
+
+        for ($i = 0;$i < $this->iterations;$i++) {
+            $this->emitter->emit('foo', []);
+        }
+
+    }
+
+}
+
+class ManyCallBacks extends BenchMark {
+
+    protected $emitter;
+
+    function setUp() {
+
+        $this->emitter = new EventEmitter();
+        for ($i = 0;$i < 100;$i++) {
+            $this->emitter->on('foo', function() {
+                // NOOP
+            });
+        }
+
+    }
+
+    function test() {
+
+        for ($i = 0;$i < $this->iterations;$i++) {
+            $this->emitter->emit('foo', []);
+        }
+
+    }
+
+}
+
+class ManyPrioritizedCallBacks extends BenchMark {
+
+    protected $emitter;
+
+    function setUp() {
+
+        $this->emitter = new EventEmitter();
+        for ($i = 0;$i < 100;$i++) {
+            $this->emitter->on('foo', function() {
+            }, 1000 - $i);
+        }
+
+    }
+
+    function test() {
+
+        for ($i = 0;$i < $this->iterations;$i++) {
+            $this->emitter->emit('foo', []);
+        }
+
+    }
+
+}
+
+$tests = [
+    'OneCallBack',
+    'ManyCallBacks',
+    'ManyPrioritizedCallBacks',
+];
+
+foreach ($tests as $test) {
+
+    $testObj = new $test();
+    $result = $testObj->go();
+    echo $test . " " . $result . "\n";
+
+}

Overview

Request 1878 (accepted)

Request History