Add lazy promise

Author: jsor

src/React/Promise/LazyPromise.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace React\Promise;
+
+class LazyPromise implements PromiseInterface
+{
+    private $factory;
+    private $promise;
+
+    public function __construct($factory)
+    {
+        $this->factory = $factory;
+    }
+
+    public function then($fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
+    {
+        if (null === $this->promise) {
+            try {
+                $this->promise = Util::promiseFor(call_user_func($this->factory));
+            } catch (\Exception $exception) {
+                $this->promise = new RejectedPromise($exception);
+            }
+        }
+
+        return $this->promise->then($fulfilledHandler, $errorHandler, $progressHandler);
+    }
+}

src/React/Promise/When.php

@@ -14,6 +14,11 @@ public static function reject($promiseOrValue = null)
         return Util::rejectedPromiseFor($promiseOrValue);
     }
 
+    public static function lazy($factory)
+    {
+        return new LazyPromise($factory);
+    }
+
     public static function all($promisesOrValues, $fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
     {
         $promise = static::map($promisesOrValues, function ($val) {

tests/React/Promise/LazyPromiseTest.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace React\Promise;
+
+/**
+ * @group Promise
+ * @group LazyPromise
+ */
+class LazyPromiseTest extends TestCase
+{
+    /** @test */
+    public function shouldNotCallFactoryIfThenIsNotInvoked()
+    {
+        $factory = $this->createCallableMock();
+        $factory
+            ->expects($this->never())
+            ->method('__invoke');
+
+        new LazyPromise($factory);
+    }
+
+    /** @test */
+    public function shouldCallFactoryIfThenIsInvoked()
+    {
+        $factory = $this->createCallableMock();
+        $factory
+            ->expects($this->once())
+            ->method('__invoke');
+
+        $p = new LazyPromise($factory);
+        $p->then();
+    }
+
+    /** @test */
+    public function shouldReturnPromiseFromFactory()
+    {
+        $factory = $this->createCallableMock();
+        $factory
+            ->expects($this->once())
+            ->method('__invoke')
+            ->will($this->returnValue(new FulfilledPromise(1)));
+
+        $fulfilledHandler = $this->createCallableMock();
+        $fulfilledHandler
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo(1));
+
+        $p = new LazyPromise($factory);
+
+        $p->then($fulfilledHandler);
+    }
+
+    /** @test */
+    public function shouldReturnPromiseIfFactoryReturnsNull()
+    {
+        $factory = $this->createCallableMock();
+        $factory
+            ->expects($this->once())
+            ->method('__invoke')
+            ->will($this->returnValue(null));
+
+        $p = new LazyPromise($factory);
+        $this->assertInstanceOf('React\\Promise\\PromiseInterface', $p->then());
+    }
+}