Merge remote-tracking branch 'jsor/promise-2.0'

igorw · igorw · commit f690b165e12d · 2013-12-10T19:58:45.000+01:00
* jsor/promise-2.0:
  Add note to CHANGELOG
  Update to React/Promise 2.0
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,7 @@ CHANGELOG
   * BC break: [HttpClient] Drop unused `Response::getBody()`
   * BC break: Bump minimum PHP version to PHP 5.4, remove 5.3 specific hacks
   * BC break: Remove `$loop` argument from `HttpClient`: `Client`, `Request`, `Response`
+  * BC break: Update to React/Promise 2.0
   * Bug fix: [Dns] Properly resolve CNAME aliases
   * Bug fix: [EventLoop] No error on removing non-existent streams (@clue)
   * Bug fix: [EventLoop] Do not silently remove feof listeners in `LibEvLoop`
diff --git a/composer.json b/composer.json
@@ -11,7 +11,7 @@
         "php": ">=5.4.0",
         "evenement/evenement": "1.0.*",
         "guzzle/parser": "~3.0",
-        "react/promise": "~1.0"
+        "react/promise": "~2.0"
     },
     "replace": {
         "react/event-loop": "self.version",
diff --git a/composer.lock b/composer.lock
diff --git a/src/React/Cache/ArrayCache.php b/src/React/Cache/ArrayCache.php
@@ -2,7 +2,7 @@
 
 namespace React\Cache;
 
-use React\Promise\When;
+use React\Promise;
 
 class ArrayCache implements CacheInterface
 {
@@ -11,10 +11,10 @@ class ArrayCache implements CacheInterface
     public function get($key)
     {
         if (!isset($this->data[$key])) {
-            return When::reject();
+            return Promise\reject();
         }
 
-        return When::resolve($this->data[$key]);
+        return Promise\resolve($this->data[$key]);
     }
 
     public function set($key, $value)
diff --git a/src/React/Dns/Config/FilesystemFactory.php b/src/React/Dns/Config/FilesystemFactory.php
@@ -3,8 +3,8 @@
 namespace React\Dns\Config;
 
 use React\EventLoop\LoopInterface;
+use React\Promise;
 use React\Promise\Deferred;
-use React\Promise\When;
 use React\Stream\Stream;
 
 class FilesystemFactory
@@ -38,13 +38,13 @@ public function parseEtcResolvConf($contents)
         $config = new Config();
         $config->nameservers = $nameservers;
 
-        return When::resolve($config);
+        return Promise\resolve($config);
     }
 
     public function loadEtcResolvConf($filename)
     {
         if (!file_exists($filename)) {
-            return When::reject(new \InvalidArgumentException("The filename for /etc/resolv.conf given does not exist: $filename"));
+            return Promise\reject(new \InvalidArgumentException("The filename for /etc/resolv.conf given does not exist: $filename"));
         }
 
         try {
@@ -68,7 +68,7 @@ public function loadEtcResolvConf($filename)
 
             return $deferred->promise();
         } catch (\Exception $e) {
-            return When::reject($e);
+            return Promise\reject($e);
         }
     }
 }
diff --git a/src/React/Dns/Query/CachedExecutor.php b/src/React/Dns/Query/CachedExecutor.php
@@ -4,7 +4,6 @@
 
 use React\Dns\Model\Message;
 use React\Dns\Model\Record;
-use React\Promise\When;
 
 class CachedExecutor implements ExecutorInterface
 {
diff --git a/src/React/Dns/Query/RecordCache.php b/src/React/Dns/Query/RecordCache.php
@@ -5,7 +5,7 @@
 use React\Cache\CacheInterface;
 use React\Dns\Model\Message;
 use React\Dns\Model\Record;
-use React\Promise\When;
+use React\Promise;
 
 class RecordCache
 {
@@ -29,7 +29,7 @@ public function lookup(Query $query)
                 $recordBag = unserialize($value);
 
                 if (null !== $expiredAt && $expiredAt <= $query->currentTime) {
-                    return When::reject();
+                    return Promise\reject();
                 }
 
                 return $recordBag->all();
diff --git a/src/React/Dns/Query/RetryExecutor.php b/src/React/Dns/Query/RetryExecutor.php
@@ -19,16 +19,16 @@ public function query($nameserver, Query $query)
     {
         $deferred = new Deferred();
 
-        $this->tryQuery($nameserver, $query, $this->retries, $deferred->resolver());
+        $this->tryQuery($nameserver, $query, $this->retries, $deferred);
 
         return $deferred->promise();
     }
 
-    public function tryQuery($nameserver, Query $query, $retries, $resolver)
+    public function tryQuery($nameserver, Query $query, $retries, $deferred)
     {
-        $errorback = function ($error) use ($nameserver, $query, $retries, $resolver) {
+        $errorback = function ($error) use ($nameserver, $query, $retries, $deferred) {
             if (!$error instanceof TimeoutException) {
-                $resolver->reject($error);
+                $deferred->reject($error);
                 return;
             }
             if (0 >= $retries) {
@@ -37,14 +37,14 @@ public function tryQuery($nameserver, Query $query, $retries, $resolver)
                     0,
                     $error
                 );
-                $resolver->reject($error);
+                $deferred->reject($error);
                 return;
             }
-            $this->tryQuery($nameserver, $query, $retries-1, $resolver);
+            $this->tryQuery($nameserver, $query, $retries-1, $deferred);
         };
 
         $this->executor
             ->query($nameserver, $query)
-            ->then(array($resolver, 'resolve'), $errorback);
+            ->then(array($deferred, 'resolve'), $errorback);
     }
 }
diff --git a/src/React/SocketClient/Connector.php b/src/React/SocketClient/Connector.php
@@ -5,7 +5,7 @@
 use React\EventLoop\LoopInterface;
 use React\Dns\Resolver\Resolver;
 use React\Stream\Stream;
-use React\Promise\When;
+use React\Promise;
 use React\Promise\Deferred;
 
 class Connector implements ConnectorInterface
@@ -35,7 +35,7 @@ public function createSocketForAddress($address, $port)
         $socket = stream_socket_client($url, $errno, $errstr, 0, STREAM_CLIENT_CONNECT | STREAM_CLIENT_ASYNC_CONNECT);
 
         if (!$socket) {
-            return When::reject(new \RuntimeException(
+            return Promise\reject(new \RuntimeException(
                 sprintf("connection to %s:%d failed: %s", $address, $port, $errstr),
                 $errno
             ));
@@ -71,10 +71,10 @@ public function checkConnectedSocket($socket)
         // The following hack looks like the only way to
         // detect connection refused errors with PHP's stream sockets.
         if (false === stream_socket_get_name($socket, true)) {
-            return When::reject(new ConnectionException('Connection refused'));
+            return Promise\reject(new ConnectionException('Connection refused'));
         }
 
-        return When::resolve($socket);
+        return Promise\resolve($socket);
     }
 
     public function handleConnectedSocket($socket)
@@ -94,7 +94,7 @@ protected function getSocketUrl($host, $port)
     protected function resolveHostname($host)
     {
         if (false !== filter_var($host, FILTER_VALIDATE_IP)) {
-            return When::resolve($host);
+            return Promise\resolve($host);
         }
 
         return $this->resolver->resolve($host);
diff --git a/src/React/SocketClient/SecureConnector.php b/src/React/SocketClient/SecureConnector.php
@@ -4,7 +4,6 @@
 
 use React\EventLoop\LoopInterface;
 use React\Stream\Stream;
-use React\Promise\When;
 
 class SecureConnector implements ConnectorInterface
 {
diff --git a/src/React/SocketClient/StreamEncryption.php b/src/React/SocketClient/StreamEncryption.php
@@ -2,7 +2,6 @@
 
 namespace React\SocketClient;
 
-use React\Promise\ResolverInterface;
 use React\Promise\Deferred;
 use React\Stream\Stream;
 use React\EventLoop\LoopInterface;
@@ -55,7 +54,7 @@ public function toggle(Stream $stream, $toggle)
         $this->loop->addReadStream($socket, $toggleCrypto);
         $toggleCrypto();
 
-        return $deferred->then(function () use ($stream) {
+        return $deferred->promise()->then(function () use ($stream) {
             $stream->resume();
             return $stream;
         }, function($error) use ($stream) {
@@ -64,7 +63,7 @@ public function toggle(Stream $stream, $toggle)
         });
     }
 
-    public function toggleCrypto($socket, ResolverInterface $resolver, $toggle)
+    public function toggleCrypto($socket, Deferred $deferred, $toggle)
     {
         set_error_handler(array($this, 'handleError'));
         $result = stream_socket_enable_crypto($socket, $toggle, $this->method);
@@ -74,12 +73,12 @@ public function toggleCrypto($socket, ResolverInterface $resolver, $toggle)
             $this->loop->removeWriteStream($socket);
             $this->loop->removeReadStream($socket);
 
-            $resolver->resolve();
+            $deferred->resolve();
         } else if (false === $result) {
             $this->loop->removeWriteStream($socket);
             $this->loop->removeReadStream($socket);
 
-            $resolver->reject(new UnexpectedValueException(
+            $deferred->reject(new UnexpectedValueException(
                 sprintf("Unable to complete SSL/TLS handshake: %s", $this->errstr),
                 $this->errno
             ));
diff --git a/tests/React/Tests/Dns/Query/CachedExecutorTest.php b/tests/React/Tests/Dns/Query/CachedExecutorTest.php
@@ -6,7 +6,7 @@
 use React\Dns\Query\Query;
 use React\Dns\Model\Message;
 use React\Dns\Model\Record;
-use React\Promise\When;
+use React\Promise;
 
 class CachedExecutorTest extends \PHPUnit_Framework_TestCase
 {
@@ -29,7 +29,7 @@ public function queryShouldDelegateToDecoratedExecutor()
         $cache
             ->expects($this->once())
             ->method('lookup')
-            ->will($this->returnValue(When::reject()));
+            ->will($this->returnValue(Promise\reject()));
         $cachedExecutor = new CachedExecutor($executor, $cache);
 
         $query = new Query('igor.io', Message::TYPE_A, Message::CLASS_IN, 1345656451);
@@ -57,7 +57,7 @@ public function callingQueryTwiceShouldUseCachedResult()
             ->expects($this->at(0))
             ->method('lookup')
             ->with($this->isInstanceOf('React\Dns\Query\Query'))
-            ->will($this->returnValue(When::reject()));
+            ->will($this->returnValue(Promise\reject()));
         $cache
             ->expects($this->at(1))
             ->method('storeResponseMessage')
@@ -66,7 +66,7 @@ public function callingQueryTwiceShouldUseCachedResult()
             ->expects($this->at(2))
             ->method('lookup')
             ->with($this->isInstanceOf('React\Dns\Query\Query'))
-            ->will($this->returnValue(When::resolve($cachedRecords)));
+            ->will($this->returnValue(Promise\resolve($cachedRecords)));
 
         $cachedExecutor = new CachedExecutor($executor, $cache);
 
@@ -83,7 +83,7 @@ private function callQueryCallbackWithAddress($address)
             $response->questions[] = new Record($query->name, $query->type, $query->class);
             $response->answers[] = new Record($query->name, $query->type, $query->class, 3600, $address);
 
-            return When::resolve($response);
+            return Promise\resolve($response);
         });
     }
 
diff --git a/tests/React/Tests/Dns/Query/RetryExecutorTest.php b/tests/React/Tests/Dns/Query/RetryExecutorTest.php
@@ -7,7 +7,7 @@
 use React\Dns\Model\Message;
 use React\Dns\Query\TimeoutException;
 use React\Dns\Model\Record;
-use React\Promise\When;
+use React\Promise;
 
 class RetryExecutorTest extends \PHPUnit_Framework_TestCase
 {
@@ -45,10 +45,10 @@ public function queryShouldRetryQueryOnTimeout()
             ->with('8.8.8.8', $this->isInstanceOf('React\Dns\Query\Query'))
             ->will($this->onConsecutiveCalls(
                 $this->returnCallback(function ($domain, $query) {
-                    return When::reject(new TimeoutException("timeout"));
+                    return Promise\reject(new TimeoutException("timeout"));
                 }),
                 $this->returnCallback(function ($domain, $query) use ($response) {
-                    return When::resolve($response);
+                    return Promise\resolve($response);
                 })
             ));
 
@@ -78,7 +78,7 @@ public function queryShouldStopRetryingAfterSomeAttempts()
             ->method('query')
             ->with('8.8.8.8', $this->isInstanceOf('React\Dns\Query\Query'))
             ->will($this->returnCallback(function ($domain, $query) {
-                return When::reject(new TimeoutException("timeout"));
+                return Promise\reject(new TimeoutException("timeout"));
             }));
 
         $callback = $this->expectCallableNever();
@@ -107,7 +107,7 @@ public function queryShouldForwardNonTimeoutErrors()
             ->method('query')
             ->with('8.8.8.8', $this->isInstanceOf('React\Dns\Query\Query'))
             ->will($this->returnCallback(function ($domain, $query) {
-                return When::reject(new \Exception);
+                return Promise\reject(new \Exception);
             }));
 
         $callback = $this->expectCallableNever();
diff --git a/tests/React/Tests/Dns/Resolver/ResolverTest.php b/tests/React/Tests/Dns/Resolver/ResolverTest.php

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace React\Cache;`
`4`	`4`
`5`		`-use React\Promise\When;`
	`5`	`+use React\Promise;`
`6`	`6`
`7`	`7`	`class ArrayCache implements CacheInterface`
`8`	`8`	`{`
`@@ -11,10 +11,10 @@ class ArrayCache implements CacheInterface`
`11`	`11`	`public function get($key)`
`12`	`12`	`{`
`13`	`13`	`if (!isset($this->data[$key])) {`
`14`		`- return When::reject();`
	`14`	`+ return Promise\reject();`
`15`	`15`	`}`
`16`	`16`
`17`		`- return When::resolve($this->data[$key]);`
	`17`	`+ return Promise\resolve($this->data[$key]);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public function set($key, $value)`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@`
`3`	`3`	`namespace React\Dns\Config;`
`4`	`4`
`5`	`5`	`use React\EventLoop\LoopInterface;`
	`6`	`+use React\Promise;`
`6`	`7`	`use React\Promise\Deferred;`
`7`		`-use React\Promise\When;`
`8`	`8`	`use React\Stream\Stream;`
`9`	`9`
`10`	`10`	`class FilesystemFactory`
`@@ -38,13 +38,13 @@ public function parseEtcResolvConf($contents)`
`38`	`38`	`$config = new Config();`
`39`	`39`	`$config->nameservers = $nameservers;`
`40`	`40`
`41`		`- return When::resolve($config);`
	`41`	`+ return Promise\resolve($config);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public function loadEtcResolvConf($filename)`
`45`	`45`	`{`
`46`	`46`	`if (!file_exists($filename)) {`
`47`		`- return When::reject(new \InvalidArgumentException("The filename for /etc/resolv.conf given does not exist: $filename"));`
	`47`	`+ return Promise\reject(new \InvalidArgumentException("The filename for /etc/resolv.conf given does not exist: $filename"));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`try {`
`@@ -68,7 +68,7 @@ public function loadEtcResolvConf($filename)`
`68`	`68`
`69`	`69`	`return $deferred->promise();`
`70`	`70`	`} catch (\Exception $e) {`
`71`		`- return When::reject($e);`
	`71`	`+ return Promise\reject($e);`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`
`5`	`5`	`use React\Dns\Model\Message;`
`6`	`6`	`use React\Dns\Model\Record;`
`7`		`-use React\Promise\When;`
`8`	`7`
`9`	`8`	`class CachedExecutor implements ExecutorInterface`
`10`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`use React\Cache\CacheInterface;`
`6`	`6`	`use React\Dns\Model\Message;`
`7`	`7`	`use React\Dns\Model\Record;`
`8`		`-use React\Promise\When;`
	`8`	`+use React\Promise;`
`9`	`9`
`10`	`10`	`class RecordCache`
`11`	`11`	`{`
`@@ -29,7 +29,7 @@ public function lookup(Query $query)`
`29`	`29`	`$recordBag = unserialize($value);`
`30`	`30`
`31`	`31`	`if (null !== $expiredAt && $expiredAt <= $query->currentTime) {`
`32`		`- return When::reject();`
	`32`	`+ return Promise\reject();`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`return $recordBag->all();`
Original file line number	Diff line number	Diff line change
`@@ -19,16 +19,16 @@ public function query($nameserver, Query $query)`
`19`	`19`	`{`
`20`	`20`	`$deferred = new Deferred();`
`21`	`21`
`22`		`- $this->tryQuery($nameserver, $query, $this->retries, $deferred->resolver());`
	`22`	`+ $this->tryQuery($nameserver, $query, $this->retries, $deferred);`
`23`	`23`
`24`	`24`	`return $deferred->promise();`
`25`	`25`	`}`
`26`	`26`
`27`		`- public function tryQuery($nameserver, Query $query, $retries, $resolver)`
	`27`	`+ public function tryQuery($nameserver, Query $query, $retries, $deferred)`
`28`	`28`	`{`
`29`		`- $errorback = function ($error) use ($nameserver, $query, $retries, $resolver) {`
	`29`	`+ $errorback = function ($error) use ($nameserver, $query, $retries, $deferred) {`
`30`	`30`	`if (!$error instanceof TimeoutException) {`
`31`		`- $resolver->reject($error);`
	`31`	`+ $deferred->reject($error);`
`32`	`32`	`return;`
`33`	`33`	`}`
`34`	`34`	`if (0 >= $retries) {`
`@@ -37,14 +37,14 @@ public function tryQuery($nameserver, Query $query, $retries, $resolver)`
`37`	`37`	`0,`
`38`	`38`	`$error`
`39`	`39`	`);`
`40`		`- $resolver->reject($error);`
	`40`	`+ $deferred->reject($error);`
`41`	`41`	`return;`
`42`	`42`	`}`
`43`		`- $this->tryQuery($nameserver, $query, $retries-1, $resolver);`
	`43`	`+ $this->tryQuery($nameserver, $query, $retries-1, $deferred);`
`44`	`44`	`};`
`45`	`45`
`46`	`46`	`$this->executor`
`47`	`47`	`->query($nameserver, $query)`
`48`		`- ->then(array($resolver, 'resolve'), $errorback);`
	`48`	`+ ->then(array($deferred, 'resolve'), $errorback);`
`49`	`49`	`}`
`50`	`50`	`}`