Make wait() a method of PromiseInterface

src/Promise/Promise.php

@@ -312,6 +312,22 @@ function (callable $resolve) use ($time) {
             }
         );
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function wait()
+    {
+        while (null === $this->result) {
+            if (Loop\isEmpty()) {
+                throw new UnresolvedError('Loop emptied without resolving promise.');
+            }
+
+            Loop\tick(true);
+        }
+
+        return $this->unwrap()->wait();
+    }
 
     /**
      * {@inheritdoc}

src/Promise/PromiseInterface.php

@@ -143,6 +143,20 @@ public function isCancelled();
      * @throws \Icicle\Promise\Exception\UnresolvedError If the promise has not been resolved.
      */
     public function getResult();
+
+    /**
+     * This function may be used to synchronously wait for a promise to be resolved. This function should generally
+     * not be used within a running event loop, but rather to set up a task (or set of tasks, then use join() or another
+     * function to group them) and synchronously wait for the task to complete. Using this function in a running event
+     * loop will not block the loop, but it will prevent control from moving past the call to this function and disrupt
+     * program flow.
+     *
+     * @return mixed Promise fulfillment value.
+     *
+     * @throws \Icicle\Promise\Exception\UnresolvedError If the event loop empties without fulfilling the promise.
+     * @throws \Exception If the promise is rejected, the rejection reason is thrown from this function.
+     */
+    public function wait();
 
     /**
      * Iteratively finds the last promise in the pending chain and returns it. 

src/Promise/Structures/CancelledPromise.php

@@ -97,4 +97,12 @@ public function getResult()
     {
         return $this->result->getResult();
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function wait()
+    {
+        return $this->result->wait();
+    }
 }

src/Promise/Structures/FulfilledPromise.php

@@ -107,4 +107,12 @@ public function getResult()
     {
         return $this->value;
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function wait()
+    {
+        return $this->value;
+    }
 }

src/Promise/Structures/LazyPromise.php

@@ -133,6 +133,14 @@ public function getResult()
     {
         return $this->getPromise()->getResult();
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function wait()
+    {
+        return $this->getPromise()->wait();
+    }
 
     /**
      * {@inheritdoc}

src/Promise/Structures/RejectedPromise.php

@@ -90,4 +90,12 @@ public function getResult()
     {
         return $this->exception;
     }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function wait()
+    {
+        throw $this->exception;
+    }
 }

src/Promise/functions.php

@@ -145,39 +145,6 @@ function lazy(callable $promisor /* ...$args */)
         });
     }
 
-    /**
-     * This function may be used to synchronously wait for a promise to be resolved. This function should generally
-     * not be used within a running event loop, but rather to set up a task (or set of tasks, then use join() or another
-     * function to group them) and synchronously wait for the task to complete. Using this function in a running event
-     * loop will not block the loop, but it will prevent control from moving past the call to this function and disrupt
-     * program flow.
-     *
-     * @param PromiseInterface $promise
-     *
-     * @return mixed Promise fulfillment value.
-     *
-     * @throws \Icicle\Promise\Exception\UnresolvedError If the event loop empties without fulfilling the promise.
-     * @throws \Exception If the promise is rejected, the rejection reason is thrown from this function.
-     */
-    function wait(PromiseInterface $promise)
-    {
-        while ($promise->isPending()) {
-            if (Loop\isEmpty()) {
-                throw new UnresolvedError('Loop emptied without resolving promise.');
-            }
-
-            Loop\tick(true);
-        }
-
-        $result = $promise->getResult();
-
-        if ($promise->isRejected()) {
-            throw $result;
-        }
-
-        return $result;
-    }
-
     /**
      * Returns a promise that is resolved when all promises are resolved. The returned promise will not reject by itself
      * (only if cancelled). Returned promise is fulfilled with an array of resolved promises, with keys identical and

tests/Promise/PromiseTest.php

@@ -2383,4 +2383,57 @@ public function testSplatWithTraversable()
 
         $this->assertTrue($child->isFulfilled());
     }
+
+    public function testWaitOnFulfilledPromise()
+    {
+        $value = 'test';
+
+        $this->resolve($value);
+
+        $result = $this->promise->wait();
+
+        $this->assertSame($value, $result);
+    }
+
+    public function testWaitOnRejectedPromise()
+    {
+        $exception = new Exception();
+
+        $this->reject($exception);
+
+        try {
+            $result = $this->promise->wait();
+            $this->fail('Rejection exception should be thrown from wait().');
+        } catch (Exception $e) {
+            $this->assertSame($exception, $e);
+        }
+    }
+
+    /**
+     * @depends testWaitOnFulfilledPromise
+     */
+    public function testWaitOnPendingPromise()
+    {
+        $value = 'test';
+
+        $promise = $this->promise->delay(0.1);
+
+        $this->resolve($value);
+
+        $this->assertTrue($promise->isPending());
+
+        $result = $promise->wait();
+
+        $this->assertSame($value, $result);
+    }
+
+    /**
+     * @expectedException \Icicle\Promise\Exception\UnresolvedError
+     */
+    public function testPromiseWithNoResolutionPathThrowsException()
+    {
+        $promise = new Promise\Promise(function () {});
+
+        $result = $promise->wait();
+    }
 }