Merge remote-tracking branch 'origin/util-when-refactoring'

* origin/util-when-refactoring:
  Use When methods in tests instead of direct promise instances
  Move Util::resolve() and Util::reject() to When (Util is now only used internally)

Author: igorw

README.md

@@ -24,9 +24,8 @@ Table of Contents
      * [When::some()](#whensome)
      * [When::map()](#whenmap)
      * [When::reduce()](#whenreduce)
-   * [Util](#util)
-     * [Util::resolve()](#utilresolve)
-     * [Util::reject()](#utilreject)
+     * [When::resolve()](#whenresolve)
+     * [When::reject()](#whenreject)
 4. [Examples](#examples)
    * [How to use Deferred](#how-to-use-deferred)
    * [How Promise forwarding works](#how-promise-forwarding-works)
@@ -237,14 +236,10 @@ Promises and/or values, and `$reduceFunc` may return either a value or a
 Promise, *and* `$initialValue` may be a Promise or a value for the starting
 value.
 
-### Util
-
-The `React\Promise\Util` class provides useful methods for creating Promises.
-
-#### Util::resolve()
+#### When::resolve()
 
 ``` php
-$promise = React\Promise\Util::resolve(mixed $promiseOrValue);
+$promise = React\Promise\When::resolve(mixed $promiseOrValue);
 ```
 
 Creates a resolved Promise for the supplied `$promiseOrValue`.
@@ -254,10 +249,10 @@ returned Promise.
 
 If `$promiseOrValue` is a Promise, it will simply be returned.
 
-#### Util::reject()
+#### When::reject()
 
 ``` php
-$promise = React\Promise\Util::reject(mixed $promiseOrValue);
+$promise = React\Promise\When::reject(mixed $promiseOrValue);
 ```
 
 Creates a rejected Promise for the supplied `$promiseOrValue`.

src/React/Promise/Deferred.php

@@ -48,10 +48,13 @@ public function then($fulfilledHandler = null, $errorHandler = null, $progressHa
     public function resolve($result = null)
     {
         if (null !== $this->completed) {
-            return Util::resolve($result);
+            $deferred = new static();
+            $deferred->resolve($result);
+
+            return $deferred->promise();
         }
 
-        $this->completed = Util::resolve($result);
+        $this->completed = Util::promiseFor($result);
 
         $this->processQueue($this->handlers, $this->completed);
 

src/React/Promise/FulfilledPromise.php

@@ -19,7 +19,7 @@ public function then($fulfilledHandler = null, $errorHandler = null, $progressHa
                 $result = call_user_func($fulfilledHandler, $result);
             }
 
-            return Util::resolve($result);
+            return Util::promiseFor($result);
         } catch (\Exception $exception) {
             return new RejectedPromise($exception);
         }

src/React/Promise/RejectedPromise.php

@@ -18,7 +18,7 @@ public function then($fulfilledHandler = null, $errorHandler = null, $progressHa
                 return new RejectedPromise($this->error);
             }
 
-            return Util::resolve(call_user_func($errorHandler, $this->error));
+            return Util::promiseFor(call_user_func($errorHandler, $this->error));
         } catch (\Exception $exception) {
             return new RejectedPromise($exception);
         }

src/React/Promise/Util.php

@@ -4,19 +4,12 @@
 
 class Util
 {
-    public static function resolve($promiseOrValue)
+    public static function promiseFor($promiseOrValue)
     {
         if ($promiseOrValue instanceof PromiseInterface) {
             return $promiseOrValue;
         }
 
         return new FulfilledPromise($promiseOrValue);
     }
-
-    public static function reject($promiseOrValue)
-    {
-        return static::resolve($promiseOrValue)->then(function ($value = null) {
-            return new RejectedPromise($value);
-        });
-    }
 }

src/React/Promise/When.php

@@ -4,6 +4,21 @@
 
 class When
 {
+    public static function resolve($promiseOrValue)
+    {
+        $deferred = new Deferred();
+        $deferred->resolve($promiseOrValue);
+
+        return $deferred->promise();
+    }
+
+    public static function reject($promiseOrValue)
+    {
+        return static::resolve($promiseOrValue)->then(function ($value = null) {
+            return new RejectedPromise($value);
+        });
+    }
+
     public static function all($promisesOrValues, $fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
     {
         $promise = static::map($promisesOrValues, function ($val) {
@@ -26,7 +41,7 @@ public static function any($promisesOrValues, $fulfilledHandler = null, $errorHa
 
     public static function some($promisesOrValues, $howMany, $fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
     {
-        return Util::resolve($promisesOrValues)->then(function ($array) use ($howMany, $fulfilledHandler, $errorHandler, $progressHandler) {
+        return When::resolve($promisesOrValues)->then(function ($array) use ($howMany, $fulfilledHandler, $errorHandler, $progressHandler) {
             if (!is_array($array)) {
                 $array = array();
             }
@@ -79,7 +94,7 @@ public static function some($promisesOrValues, $howMany, $fulfilledHandler = nul
                         }
                     };
 
-                    Util::resolve($promiseOrValue)->then($fulfiller, $rejecter, $progress);
+                    When::resolve($promiseOrValue)->then($fulfiller, $rejecter, $progress);
                 }
             }
 
@@ -89,7 +104,7 @@ public static function some($promisesOrValues, $howMany, $fulfilledHandler = nul
 
     public static function map($promisesOrValues, $mapFunc)
     {
-        return Util::resolve($promisesOrValues)->then(function ($array) use ($mapFunc) {
+        return When::resolve($promisesOrValues)->then(function ($array) use ($mapFunc) {
             if (!is_array($array)) {
                 $array = array();
             }
@@ -102,7 +117,7 @@ public static function map($promisesOrValues, $mapFunc)
                 $deferred->resolve($results);
             } else {
                 $resolve = function ($item, $i) use ($mapFunc, &$results, &$toResolve, $deferred) {
-                    Util::resolve($item)
+                    When::resolve($item)
                         ->then($mapFunc)
                         ->then(
                             function ($mapped) use (&$results, $i, &$toResolve, $deferred) {
@@ -127,7 +142,7 @@ function ($mapped) use (&$results, $i, &$toResolve, $deferred) {
 
     public static function reduce($promisesOrValues, $reduceFunc , $initialValue = null)
     {
-        return Util::resolve($promisesOrValues)->then(function ($array) use ($reduceFunc, $initialValue) {
+        return When::resolve($promisesOrValues)->then(function ($array) use ($reduceFunc, $initialValue) {
             if (!is_array($array)) {
                 $array = array();
             }
@@ -138,8 +153,8 @@ public static function reduce($promisesOrValues, $reduceFunc , $initialValue = n
             // Wrap the supplied $reduceFunc with one that handles promises and then
             // delegates to the supplied.
             $wrappedReduceFunc = function ($current, $val) use ($reduceFunc, $total, &$i) {
-                return Util::resolve($current)->then(function ($c) use ($reduceFunc, $total, &$i, $val) {
-                    return Util::resolve($val)->then(function ($value) use ($reduceFunc, $total, &$i, $c) {
+                return When::resolve($current)->then(function ($c) use ($reduceFunc, $total, &$i, $val) {
+                    return When::resolve($val)->then(function ($value) use ($reduceFunc, $total, &$i, $c) {
                         return call_user_func($reduceFunc, $c, $value, $i++, $total);
                     });
                 });

tests/React/Promise/DeferredRejectTest.php

@@ -33,20 +33,16 @@ public function shouldReturnAPromiseForTheRejectionValue()
     {
         $d = new Deferred();
 
-        $self = $this;
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo(1));
 
         $d
             ->resolver()
             ->reject(1)
-            ->then($this->expectCallableNever(), function ($returnedPromiseVal) use ($d, $self) {
-                $mock = $self->createCallableMock();
-                $mock
-                    ->expects($self->once())
-                    ->method('__invoke')
-                    ->with($self->identicalTo($returnedPromiseVal));
-
-                $d->then($self->expectCallableNever(), $mock);
-            });
+            ->then($this->expectCallableNever(), $mock);
     }
 
     /** @test */

tests/React/Promise/DeferredResolveTest.php

@@ -73,62 +73,52 @@ public function shouldReturnAPromiseForTheResolutionValue()
     {
         $d = new Deferred();
 
-        $self = $this;
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo(1));
 
         $d
             ->resolver()
             ->resolve(1)
-            ->then(function ($returnedPromiseVal) use ($d, $self) {
-                $mock = $self->createCallableMock();
-                $mock
-                    ->expects($self->once())
-                    ->method('__invoke')
-                    ->with($self->identicalTo($returnedPromiseVal));
-
-                $d->then($mock);
-            });
+            ->then($mock);
     }
 
     /** @test */
     public function shouldReturnAPromiseForAPromisedResolutionValue()
     {
         $d = new Deferred();
 
-        $self = $this;
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo(1));
 
         $d
             ->resolver()
-            ->resolve(Util::resolve(1))
-            ->then(function ($returnedPromiseVal) use ($d, $self) {
-                $mock = $self->createCallableMock();
-                $mock
-                    ->expects($self->once())
-                    ->method('__invoke')
-                    ->with($self->identicalTo($returnedPromiseVal));
-
-                $d->then($mock);
-            });
+            ->resolve(When::resolve(1))
+            ->then($mock);
     }
 
     /** @test */
     public function shouldReturnAPromiseForAPromisedRejectionValue()
     {
         $d = new Deferred();
 
-        $self = $this;
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo(1));
 
+        // Both the returned promise, and the deferred's own promise should
+        // be rejected with the same value
         $d
             ->resolver()
-            ->resolve(Util::reject(1))
-            ->then($this->expectCallableNever(), function ($returnedPromiseVal) use ($d, $self) {
-                $mock = $self->createCallableMock();
-                $mock
-                    ->expects($self->once())
-                    ->method('__invoke')
-                    ->with($self->identicalTo($returnedPromiseVal));
-
-                $d->then($self->expectCallableNever(), $mock);
-            });
+            ->resolve(When::reject(1))
+            ->then($this->expectCallableNever(), $mock);
     }
 
     /** @test */

tests/React/Promise/UtilPromiseForTest.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace React\Promise;
+
+/**
+ * @group Util
+ * @group UtilPromiseFor
+ */
+class UtilPromiseForTest extends TestCase
+{
+    /** @test */
+    public function shouldResolveAnImmediateValue()
+    {
+        $expected = 123;
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($expected));
+
+        Util::promiseFor($expected)
+            ->then(
+                $mock,
+                $this->expectCallableNever()
+            );
+    }
+
+    /** @test */
+    public function shouldResolveAFulfilledPromise()
+    {
+        $expected = 123;
+
+        $resolved = new FulfilledPromise($expected);
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($expected));
+
+        Util::promiseFor($resolved)
+            ->then(
+                $mock,
+                $this->expectCallableNever()
+            );
+    }
+
+    /** @test */
+    public function shouldRejectARejectedPromise()
+    {
+        $expected = 123;
+
+        $resolved = new RejectedPromise($expected);
+
+        $mock = $this->createCallableMock();
+        $mock
+            ->expects($this->once())
+            ->method('__invoke')
+            ->with($this->identicalTo($expected));
+
+        Util::promiseFor($resolved)
+            ->then(
+                $this->expectCallableNever(),
+                $mock
+            );
+    }
+}

tests/React/Promise/WhenAllTest.php

@@ -45,7 +45,7 @@ public function shouldResolvePromisesArray()
             ->with($this->identicalTo(array(1, 2, 3)));
 
         When::all(
-            array(new FulfilledPromise(1), new FulfilledPromise(2), new FulfilledPromise(3)),
+            array(When::resolve(1), When::resolve(2), When::resolve(3)),
             $mock
         );
     }
@@ -75,7 +75,7 @@ public function shouldRejectIfAnyInputPromiseRejects()
             ->with($this->identicalTo(2));
 
         When::all(
-            array(new FulfilledPromise(1), new RejectedPromise(2), new FulfilledPromise(3)),
+            array(When::resolve(1), When::reject(2), When::resolve(3)),
             $this->expectCallableNever(),
             $mock
         );
@@ -91,7 +91,7 @@ public function shouldAcceptAPromiseForAnArray()
             ->with($this->identicalTo(array(1, 2, 3)));
 
         When::all(
-            new FulfilledPromise(array(1, 2, 3)),
+            When::resolve(array(1, 2, 3)),
             $mock
         );
     }
@@ -106,7 +106,7 @@ public function shouldResolveToEmptyArrayWhenInputPromiseDoesNotResolveToArray()
             ->with($this->identicalTo(array()));
 
         When::all(
-            new FulfilledPromise(1),
+            When::resolve(1),
             $mock
         );
     }