Merge branch 'master' into enforce-exception-reasons

Author: jsor

.travis.yml

@@ -6,8 +6,16 @@ php:
   - 5.6
   - 7.0
   - 7.1
-  - nightly
-  - hhvm
+  - nightly # ignore errors, see below
+  - hhvm # ignore errors, see below
+
+# lock distro so new future defaults will not break the build
+dist: trusty
+
+matrix:
+  allow_failures:
+    - php: hhvm
+    - php: nightly
 
 install:
   - composer install

README.md

@@ -17,7 +17,7 @@ Table of Contents
 1. [Introduction](#introduction)
 2. [Concepts](#concepts)
    * [Deferred](#deferred)
-   * [Promise](#promise)
+   * [Promise](#promise-1)
 3. [API](#api)
    * [Deferred](#deferred-1)
      * [Deferred::promise()](#deferredpromise)
@@ -29,10 +29,9 @@ Table of Contents
      * [PromiseInterface::otherwise()](#promiseinterfaceotherwise)
      * [PromiseInterface::always()](#promiseinterfacealways)
      * [PromiseInterface::cancel()](#promiseinterfacecancel)
-   * [Promise](#promise-1)
+   * [Promise](#promise-2)
    * [FulfilledPromise](#fulfilledpromise)
    * [RejectedPromise](#rejectedpromise)
-   * [LazyPromise](#lazypromise)
    * [Functions](#functions)
      * [resolve()](#resolve)
      * [reject()](#reject)
@@ -102,7 +101,7 @@ The `promise` method returns the promise of the deferred.
 The `resolve` and `reject` methods control the state of the deferred.
 
 The constructor of the `Deferred` accepts an optional `$canceller` argument.
-See [Promise](#promise-1) for more information.
+See [Promise](#promise-2) for more information.
 
 #### Deferred::promise()
 
@@ -150,10 +149,9 @@ Neither its state nor its result (or error) can be modified.
 
 #### Implementations
 
-* [Promise](#promise-1)
+* [Promise](#promise-2)
 * [FulfilledPromise](#fulfilledpromise)
 * [RejectedPromise](#rejectedpromise)
-* [LazyPromise](#lazypromise)
 
 #### PromiseInterface::then()
 
@@ -200,8 +198,8 @@ $promise->done(callable $onFulfilled = null, callable $onRejected = null);
 Consumes the promise's ultimate value if the promise fulfills, or handles the
 ultimate error.
 
-It will cause a fatal error if either `$onFulfilled` or `$onRejected` throw or
-return a rejected promise.
+It will cause a fatal error (`E_USER_ERROR`) if either `$onFulfilled` or
+`$onRejected` throw or return a rejected promise.
 
 Since the purpose of `done()` is consumption rather than transformation,
 `done()` always returns `null`.
@@ -357,27 +355,6 @@ $promise = React\Promise\RejectedPromise($reason);
 
 Note, that `$reason` **must** be a `\Throwable` or `\Exception`.
 
-### LazyPromise
-
-Creates a promise which will be lazily initialized by `$factory` once a consumer
-calls the `then()` method.
-
-```php
-$factory = function () {
-    $deferred = new React\Promise\Deferred();
-
-    // Do some heavy stuff here and resolve the deferred once completed
-
-    return $deferred->promise();
-};
-
-$promise = new React\Promise\LazyPromise($factory);
-
-// $factory will only be executed once we call then()
-$promise->then(function ($value) {
-});
-```
-
 ### Functions
 
 Useful functions for creating, joining, mapping and reducing collections of
@@ -660,8 +637,8 @@ by the promise machinery and used to reject the promise returned by `then()`.
 
 Calling `done()` transfers all responsibility for errors to your code. If an
 error (either a thrown exception or returned rejection) escapes the
-`$onFulfilled` or `$onRejected` callbacks you provide to done, it will be
-rethrown in an uncatchable way causing a fatal error.
+`$onFulfilled` or `$onRejected` callbacks you provide to `done()`, it will cause
+a fatal error.
 
 ```php
 function getJsonResult()

src/FulfilledPromise.php

@@ -41,7 +41,13 @@ public function done(callable $onFulfilled = null, callable $onRejected = null)
         }
 
         enqueue(function () use ($onFulfilled) {
-            $result = $onFulfilled($this->value);
+            try {
+                $result = $onFulfilled($this->value);
+            } catch (\Throwable $exception) {
+                return fatalError($exception);
+            } catch (\Exception $exception) {
+                return fatalError($exception);
+            }
 
             if ($result instanceof PromiseInterface) {
                 $result->done();

src/LazyPromise.php

@@ -9,7 +9,7 @@ final class Promise implements PromiseInterface
 
     private $handlers = [];
 
-    private $remainingCancelRequests = 0;
+    private $requiredCancelRequests = 0;
 
     public function __construct(callable $resolver, callable $canceller = null)
     {
@@ -27,14 +27,14 @@ public function then(callable $onFulfilled = null, callable $onRejected = null)
             return new static($this->resolver($onFulfilled, $onRejected));
         }
 
-        $this->remainingCancelRequests++;
+        $this->requiredCancelRequests++;
 
         return new static($this->resolver($onFulfilled, $onRejected), function () {
-            if (--$this->remainingCancelRequests > 0) {
-                return;
-            }
+            $this->requiredCancelRequests--;
 
-            $this->cancel();
+            if ($this->requiredCancelRequests <= 0) {
+                $this->cancel();
+            }
         });
     }
 
@@ -76,14 +76,37 @@ public function always(callable $onFulfilledOrRejected)
 
     public function cancel()
     {
-        if (null === $this->canceller) {
-            return;
-        }
-
         $canceller = $this->canceller;
         $this->canceller = null;
 
-        $this->call($canceller);
+        $parentCanceller = null;
+
+        if (null !== $this->result) {
+            // Go up the promise chain and reach the top most promise which is
+            // itself not following another promise
+            $root = $this->unwrap($this->result);
+
+            // Return if the root promise is already resolved or a
+            // FulfilledPromise or RejectedPromise
+            if (!$root instanceof self || null !== $root->result) {
+                return;
+            }
+
+            $root->requiredCancelRequests--;
+
+            if ($root->requiredCancelRequests <= 0) {
+                $parentCanceller = [$root, 'cancel'];
+            }
+        }
+
+        if (null !== $canceller) {
+            $this->call($canceller);
+        }
+
+        // For BC, we call the parent canceller after our own canceller
+        if ($parentCanceller) {
+            $parentCanceller();
+        }
     }
 
     private function resolver(callable $onFulfilled = null, callable $onRejected = null)
@@ -119,10 +142,22 @@ private function settle(PromiseInterface $result)
     {
         $result = $this->unwrap($result);
 
+        if ($result === $this) {
+            $result = new RejectedPromise(
+                new \LogicException('Cannot resolve a promise with itself.')
+            );
+        }
+
+        if ($result instanceof self) {
+            $result->requiredCancelRequests++;
+        } else {
+            // Unset canceller only when not following a pending promise
+            $this->canceller = null;
+        }
+
         $handlers = $this->handlers;
 
         $this->handlers = [];
-        $this->canceller = null;
         $this->result = $result;
 
         foreach ($handlers as $handler) {
@@ -132,25 +167,8 @@ private function settle(PromiseInterface $result)
 
     private function unwrap($promise)
     {
-        $promise = $this->extract($promise);
-
         while ($promise instanceof self && null !== $promise->result) {
-            $promise = $this->extract($promise->result);
-        }
-
-        return $promise;
-    }
-
-    private function extract($promise)
-    {
-        if ($promise instanceof LazyPromise) {
-            $promise = $promise->promise();
-        }
-
-        if ($promise === $this) {
-            return new RejectedPromise(
-                new \LogicException('Cannot resolve a promise with itself.')
-            );
+            $promise = $promise->result;
         }
 
         return $promise;

src/Promise.php

@@ -40,13 +40,19 @@ public function done(callable $onFulfilled = null, callable $onRejected = null)
     {
         enqueue(function () use ($onRejected) {
             if (null === $onRejected) {
-                throw $this->reason;
+                return fatalError($this->reason);
             }
 
-            $result = $onRejected($this->reason);
+            try {
+                $result = $onRejected($this->reason);
+            } catch (\Throwable $exception) {
+                return fatalError($exception);
+            } catch (\Exception $exception) {
+                return fatalError($exception);
+            }
 
             if ($result instanceof self) {
-                throw $result->reason;
+                return fatalError($result->reason);
             }
 
             if ($result instanceof PromiseInterface) {

src/RejectedPromise.php

@@ -201,6 +201,22 @@ function enqueue(callable $task)
     $queue->enqueue($task);
 }
 
+/**
+ * @internal
+ */
+function fatalError($error)
+{
+    try {
+        trigger_error($error, E_USER_ERROR);
+    } catch (\Throwable $e) {
+        set_error_handler(null);
+        trigger_error($error, E_USER_ERROR);
+    } catch (\Exception $e) {
+        set_error_handler(null);
+        trigger_error($error, E_USER_ERROR);
+    }
+}
+
 /**
  * @internal
  */

src/functions.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace React\Promise;
+
+final class ErrorCollector
+{
+    private $errors = [];
+
+    public function start()
+    {
+        $errors = [];
+
+        set_error_handler(function ($errno, $errstr, $errfile, $errline, $errcontext) use (&$errors) {
+            $errors[] = compact('errno', 'errstr', 'errfile', 'errline', 'errcontext');
+        });
+
+        $this->errors = &$errors;
+    }
+
+    public function stop()
+    {
+        $errors = $this->errors;
+        $this->errors = [];
+
+        restore_error_handler();
+
+        return $errors;
+    }
+}