Implement cancellation for lazy promises

Author: clue

README.md

@@ -508,6 +508,7 @@ a promise has no effect.
 
 * [FulfilledPromise](#fulfilledpromise)
 * [RejectedPromise](#rejectedpromise)
+* [LazyPromise](#lazypromise)
 
 Examples
 --------

src/React/Promise/LazyPromise.php

@@ -2,7 +2,7 @@
 
 namespace React\Promise;
 
-class LazyPromise implements PromiseInterface
+class LazyPromise implements PromiseInterface, CancellablePromiseInterface
 {
     private $factory;
     private $promise;
@@ -13,6 +13,19 @@ public function __construct($factory)
     }
 
     public function then($fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
+    {
+        return $this->promise()->then($fulfilledHandler, $errorHandler, $progressHandler);
+    }
+
+    public function cancel()
+    {
+        $promise = $this->promise();
+        if ($promise instanceof CancellablePromiseInterface) {
+            $promise->cancel();
+        }
+    }
+
+    private function promise()
     {
         if (null === $this->promise) {
             try {
@@ -21,7 +34,6 @@ public function then($fulfilledHandler = null, $errorHandler = null, $progressHa
                 $this->promise = new RejectedPromise($exception);
             }
         }
-
-        return $this->promise->then($fulfilledHandler, $errorHandler, $progressHandler);
+        return $this->promise;
     }
 }

tests/React/Promise/LazyPromiseTest.php

@@ -63,12 +63,12 @@ public function shouldReturnPromiseIfFactoryReturnsNull()
         $p = new LazyPromise($factory);
         $this->assertInstanceOf('React\\Promise\\PromiseInterface', $p->then());
     }
-    
+
     /** @test */
     public function shouldReturnRejectedPromiseIfFactoryThrowsException()
     {
         $exception = new \Exception();
-        
+
         $factory = $this->createCallableMock();
         $factory
             ->expects($this->once())
@@ -85,4 +85,34 @@ public function shouldReturnRejectedPromiseIfFactoryThrowsException()
 
         $p->then($this->expectCallableNever(), $errorHandler);
     }
+
+    /** @test */
+    public function shouldInvokeCancellationHandlerAndStayPendingWhenCallingCancel()
+    {
+        $once = $this->expectCallableOnce();
+
+        $factory = function () use ($once){
+            return new Deferred($once);
+        };
+
+        $p = new LazyPromise($factory);
+        $p->cancel();
+
+        $p->then($this->expectCallableNever(), $this->expectCallableNever());
+    }
+
+    /** @test */
+    public function shouldNotInvokeCancellationHandlerIfPromiseIsNotCancellable()
+    {
+        $mock = $this->getMock('React\\Promise\\PromiseInterface');
+
+        $factory = function () use ($mock){
+            return $mock;
+        };
+
+        $p = new LazyPromise($factory);
+        $p->cancel();
+
+        $p->then($this->expectCallableNever(), $this->expectCallableNever());
+    }
 }