Implement AsyncInterop\Promise

composer.json

@@ -6,9 +6,11 @@
         {"name": "Jan Sorgalla", "email": "[email protected]"}
     ],
     "require": {
-        "php": ">=5.4.0"
+        "php": ">=5.4.0",
+        "async-interop/promise": "^0.4.0"
     },
     "require-dev": {
+        "async-interop/promise-test": "^0.4.1",
         "phpunit/phpunit": "~4.8"
     },
     "autoload": {

src/FulfilledPromise.php

@@ -2,13 +2,15 @@
 
 namespace React\Promise;
 
+use AsyncInterop\Promise as AsyncInteropPromise;
+
 final class FulfilledPromise implements PromiseInterface
 {
     private $value;
 
     public function __construct($value = null)
     {
-        if ($value instanceof PromiseInterface) {
+        if ($value instanceof AsyncInteropPromise) {
             throw new \InvalidArgumentException('You cannot create React\Promise\FulfilledPromise with a promise. Use React\Promise\resolve($promiseOrValue) instead.');
         }
 
@@ -66,4 +68,15 @@ public function always(callable $onFulfilledOrRejected)
     public function cancel()
     {
     }
+
+    public function when(callable $onResolved)
+    {
+        try {
+            $onResolved(null, $this->value);
+        } catch (\Throwable $exception) {
+            AsyncInteropPromise\ErrorHandler::notify($exception);
+        } catch (\Exception $exception) {
+            AsyncInteropPromise\ErrorHandler::notify($exception);
+        }
+    }
 }

src/LazyPromise.php

@@ -37,6 +37,11 @@ public function cancel()
         return $this->promise()->cancel();
     }
 
+    public function when(callable $onResolved)
+    {
+        return $this->promise()->when($onResolved);
+    }
+
     /**
      * @internal
      * @see Promise::settle()

src/Promise.php

@@ -87,6 +87,17 @@ public function cancel()
         $this->call($canceller);
     }
 
+    public function when(callable $onResolved)
+    {
+        if (null !== $this->result) {
+            return $this->result()->when($onResolved);
+        }
+
+        $this->handlers[] = function (PromiseInterface $promise) use ($onResolved) {
+            $promise->when($onResolved);
+        };
+    }
+
     private function resolver(callable $onFulfilled = null, callable $onRejected = null)
     {
         return function ($resolve, $reject) use ($onFulfilled, $onRejected) {

src/PromiseInterface.php

@@ -2,7 +2,9 @@
 
 namespace React\Promise;
 
-interface PromiseInterface
+use AsyncInterop\Promise as AsyncInteropPromise;
+
+interface PromiseInterface extends AsyncInteropPromise
 {
     /**
      * @return PromiseInterface

src/RejectedPromise.php

@@ -2,13 +2,15 @@
 
 namespace React\Promise;
 
+use AsyncInterop\Promise as AsyncInteropPromise;
+
 final class RejectedPromise implements PromiseInterface
 {
     private $reason;
 
     public function __construct($reason = null)
     {
-        if ($reason instanceof PromiseInterface) {
+        if ($reason instanceof AsyncInteropPromise) {
             throw new \InvalidArgumentException('You cannot create React\Promise\RejectedPromise with a promise. Use React\Promise\reject($promiseOrValue) instead.');
         }
 
@@ -74,4 +76,18 @@ public function always(callable $onFulfilledOrRejected)
     public function cancel()
     {
     }
+
+    public function when(callable $onResolved)
+    {
+        try {
+            $onResolved(
+                UnhandledRejectionException::resolve($this->reason),
+                null
+            );
+        } catch (\Throwable $exception) {
+            AsyncInteropPromise\ErrorHandler::notify($exception);
+        } catch (\Exception $exception) {
+            AsyncInteropPromise\ErrorHandler::notify($exception);
+        }
+    }
 }

src/functions.php

@@ -2,12 +2,27 @@
 
 namespace React\Promise;
 
+use AsyncInterop\Promise as AsyncInteropPromise;
+
 function resolve($promiseOrValue = null)
 {
     if ($promiseOrValue instanceof PromiseInterface) {
         return $promiseOrValue;
     }
 
+    if ($promiseOrValue instanceof AsyncInteropPromise) {
+        return new Promise(function ($resolve, $reject) use ($promiseOrValue) {
+            $promiseOrValue->when(function ($reason = null, $value = null) use ($resolve, $reject) {
+                if ($reason) {
+                    $reject($reason);
+                    return;
+                }
+
+                $resolve($value);
+            });
+        });
+    }
+
     if (method_exists($promiseOrValue, 'then')) {
         $canceller = null;
 
@@ -31,6 +46,14 @@ function reject($promiseOrValue = null)
         });
     }
 
+    if ($promiseOrValue instanceof AsyncInteropPromise) {
+        return new Promise(function ($resolve, $reject) use ($promiseOrValue) {
+            $promiseOrValue->when(function ($reason = null, $value = null) use ($resolve, $reject) {
+                $reject($reason ? $reason : $value);
+            });
+        });
+    }
+
     return new RejectedPromise($promiseOrValue);
 }
 

tests/AsyncInterop/DeferredTest.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace React\Promise\AsyncInterop;
+
+use AsyncInterop\Promise\Test;
+use React\Promise\Deferred;
+
+class DeferredTest extends Test
+{
+    public function promise(callable $canceller = null)
+    {
+        $d = new Deferred($canceller);
+
+        return [
+            $d->promise(),
+            [$d, 'resolve'],
+            [$d, 'reject']
+        ];
+    }
+}

tests/AsyncInterop/LazyPromiseTest.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace React\Promise\AsyncInterop;
+
+use AsyncInterop\Promise\Test;
+use React\Promise\Deferred;
+use React\Promise\LazyPromise;
+
+class LazyPromiseTest extends Test
+{
+    public function promise(callable $canceller = null)
+    {
+        $d = new Deferred($canceller);
+
+        $factory = function () use ($d) {
+            return $d->promise();
+        };
+
+        return [
+            new LazyPromise($factory),
+            [$d, 'resolve'],
+            [$d, 'reject']
+        ];
+    }
+}

tests/AsyncInterop/PromiseTest.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace React\Promise\AsyncInterop;
+
+use AsyncInterop\Promise\Test;
+use React\Promise\Promise;
+
+class PromiseTest extends Test
+{
+    public function promise(callable $canceller = null)
+    {
+        $resolveCallback = $rejectCallback = null;
+
+        $promise = new Promise(function ($resolve, $reject) use (&$resolveCallback, &$rejectCallback) {
+            $resolveCallback = $resolve;
+            $rejectCallback  = $reject;
+        }, $canceller);
+
+        return [
+            $promise,
+            $resolveCallback,
+            $rejectCallback
+        ];
+    }
+}

tests/FulfilledPromiseTest.php

@@ -44,4 +44,12 @@ public function shouldThrowExceptionIfConstructedWithAPromise()
 
         return new FulfilledPromise(new FulfilledPromise());
     }
+
+    /** @test */
+    public function shouldThrowExceptionIfConstructedWithAAsyncInteropPromise()
+    {
+        $this->setExpectedException('\InvalidArgumentException');
+
+        return new FulfilledPromise(new SimpleFulfilledAsyncInteropTestPromise());
+    }
 }

tests/FunctionRejectTest.php

@@ -42,6 +42,24 @@ public function shouldRejectAFulfilledPromise()
             );
     }
 
+    /** @test */
+    public function shouldRejectAFulfilledAsyncInteropPromise()
+    {
+        $resolved = new SimpleFulfilledAsyncInteropTestPromise();
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo('foo'));
+
+        reject($resolved)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
+
     /** @test */
     public function shouldRejectARejectedPromise()
     {
@@ -61,4 +79,23 @@ public function shouldRejectARejectedPromise()
                 $mock
             );
     }
+
+    /** @test */
+    public function shouldRejectARejectedAsyncInteropPromise()
+    {
+        $exception = new \Exception('foo');
+        $resolved = new SimpleRejectedAsyncInteropTestPromise($exception);
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($exception));
+
+        reject($resolved)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
 }

tests/FunctionResolveTest.php

@@ -71,6 +71,24 @@ public function shouldResolveACancellableThenable()
         $this->assertTrue($thenable->cancelCalled);
     }
 
+    /** @test */
+    public function shouldResolveAFulfilledAsyncInteropPromise()
+    {
+        $promise = new SimpleFulfilledAsyncInteropTestPromise();
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo('foo'));
+
+        resolve($promise)
+            ->then(
+                $mock,
+                $this->expectCallableNever()
+            );
+    }
+
     /** @test */
     public function shouldRejectARejectedPromise()
     {
@@ -91,6 +109,25 @@ public function shouldRejectARejectedPromise()
             );
     }
 
+    /** @test */
+    public function shouldRejectARejectedAsyncInteropPromise()
+    {
+        $exception = new \Exception('foo');
+        $promise = new SimpleRejectedAsyncInteropTestPromise($exception);
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($exception));
+
+        resolve($promise)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
+
     /** @test */
     public function shouldSupportDeepNestingInPromiseChains()
     {

tests/RejectedPromiseTest.php

@@ -44,4 +44,12 @@ public function shouldThrowExceptionIfConstructedWithAPromise()
 
         return new RejectedPromise(new RejectedPromise());
     }
+
+    /** @test */
+    public function shouldThrowExceptionIfConstructedWithAAsyncInteropPromise()
+    {
+        $this->setExpectedException('\InvalidArgumentException');
+
+        return new RejectedPromise(new SimpleFulfilledAsyncInteropTestPromise());
+    }
 }

tests/fixtures/SimpleFulfilledAsyncInteropTestPromise.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace React\Promise;
+
+use AsyncInterop\Promise as AsyncInteropPromise;
+
+class SimpleFulfilledAsyncInteropTestPromise implements AsyncInteropPromise
+{
+    public function when(callable $onResolved)
+    {
+        $onResolved(null, 'foo');
+    }
+}

tests/fixtures/SimpleRejectedAsyncInteropTestPromise.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace React\Promise;
+
+use AsyncInterop\Promise as AsyncInteropPromise;
+
+class SimpleRejectedAsyncInteropTestPromise implements AsyncInteropPromise
+{
+    private $exception;
+
+    public function __construct(\Exception $exception)
+    {
+        $this->exception = $exception;
+    }
+
+    public function when(callable $onResolved)
+    {
+        $onResolved($this->exception, null);
+    }
+}