1.1 release for 2.0 compatibility

.travis.yml

@@ -5,8 +5,15 @@ php:
   - 5.3
   - 5.4
   - 5.5
+  - 5.6
+  - 7.0
+  - hhvm
 
-before_script:
-  - composer install
+before_install:
+  - composer self-update
 
-script: phpunit --coverage-text
+install:
+  - composer install --prefer-source
+
+script:
+  - phpunit -v --coverage-text

composer.json

@@ -3,19 +3,20 @@
     "description": "A lightweight implementation of CommonJS Promises/A for PHP",
     "license": "MIT",
     "authors": [
-        {"name": "Jan Sorgalla", "email": "jsorgalla@googlemail.com"}
+        {"name": "Jan Sorgalla", "email": "jsorgalla@gmail.com"}
     ],
     "require": {
         "php": ">=5.3.3"
     },
     "autoload": {
         "psr-0": {
             "React\\Promise": "src/"
-        }
+        },
+        "files": ["src/React/Promise/functions.php"]
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.0-dev"
+            "dev-master": "1.1-dev"
         }
     }
 }

src/React/Promise/Deferred.php

@@ -52,10 +52,10 @@ public function then($fulfilledHandler = null, $errorHandler = null, $progressHa
     public function resolve($result = null)
     {
         if (null !== $this->completed) {
-            return Util::promiseFor($result);
+            return resolve($result);
         }
 
-        $this->completed = Util::promiseFor($result);
+        $this->completed = resolve($result);
 
         $this->processQueue($this->handlers, $this->completed);
 
@@ -66,7 +66,7 @@ public function resolve($result = null)
 
     public function reject($reason = null)
     {
-        return $this->resolve(Util::rejectedPromiseFor($reason));
+        return $this->resolve(reject($reason));
     }
 
     public function progress($update = null)

src/React/Promise/FulfilledPromise.php

@@ -22,7 +22,7 @@ public function then($fulfilledHandler = null, $errorHandler = null, $progressHa
                 trigger_error('Invalid $fulfilledHandler argument passed to then(), must be null or callable.', E_USER_NOTICE);
             }
 
-            return Util::promiseFor($result);
+            return resolve($result);
         } catch (\Exception $exception) {
             return new RejectedPromise($exception);
         }

src/React/Promise/LazyPromise.php

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

src/React/Promise/Promise.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace React\Promise;
+
+class Promise implements PromiseInterface
+{
+    private $deferred;
+
+    public function __construct($resolver, $canceller = null)
+    {
+        if (!is_callable($resolver)) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    'The resolver argument must be of type callable, %s given.',
+                    gettype($resolver)
+                )
+            );
+        }
+
+        $this->deferred = new Deferred();
+        $this->call($resolver);
+    }
+
+    public function then($fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
+    {
+        return $this->deferred->then($fulfilledHandler, $errorHandler, $progressHandler);
+    }
+
+    private function call($callback)
+    {
+        $deferred = $this->deferred;
+
+        try {
+            call_user_func(
+                $callback,
+                function ($result = null) use ($deferred) {
+                    $deferred->resolve($result);
+                },
+                function ($reason = null) use ($deferred) {
+                    $deferred->reject($reason);
+                },
+                function ($update = null) use ($deferred) {
+                    $deferred->progress($update);
+                }
+            );
+        } catch (\Exception $e) {
+            $this->deferred->reject($e);
+        }
+    }
+}

src/React/Promise/RejectedPromise.php

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

src/React/Promise/Util.php

@@ -6,21 +6,11 @@ class Util
 {
     public static function promiseFor($promiseOrValue)
     {
-        if ($promiseOrValue instanceof PromiseInterface) {
-            return $promiseOrValue;
-        }
-
-        return new FulfilledPromise($promiseOrValue);
+        return resolve($promiseOrValue);
     }
 
     public static function rejectedPromiseFor($promiseOrValue)
     {
-        if ($promiseOrValue instanceof PromiseInterface) {
-            return $promiseOrValue->then(function ($value) {
-                return new RejectedPromise($value);
-            });
-        }
-
-        return new RejectedPromise($promiseOrValue);
+        return reject($promiseOrValue);
     }
 }

src/React/Promise/When.php

@@ -6,12 +6,12 @@ class When
 {
     public static function resolve($promiseOrValue = null)
     {
-        return Util::promiseFor($promiseOrValue);
+        return resolve($promiseOrValue);
     }
 
     public static function reject($promiseOrValue = null)
     {
-        return Util::rejectedPromiseFor($promiseOrValue);
+        return reject($promiseOrValue);
     }
 
     public static function lazy($factory)
@@ -21,148 +21,26 @@ public static function lazy($factory)
 
     public static function all($promisesOrValues, $fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
     {
-        $promise = static::map($promisesOrValues, function ($val) {
-            return $val;
-        });
-
-        return $promise->then($fulfilledHandler, $errorHandler, $progressHandler);
+        return all($promisesOrValues)->then($fulfilledHandler, $errorHandler, $progressHandler);
     }
 
     public static function any($promisesOrValues, $fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
     {
-        $unwrapSingleResult = function ($val) use ($fulfilledHandler) {
-            $val = array_shift($val);
-
-            return $fulfilledHandler ? $fulfilledHandler($val) : $val;
-        };
-
-        return static::some($promisesOrValues, 1, $unwrapSingleResult, $errorHandler, $progressHandler);
+        return any($promisesOrValues)->then($fulfilledHandler, $errorHandler, $progressHandler);
     }
 
     public static function some($promisesOrValues, $howMany, $fulfilledHandler = null, $errorHandler = null, $progressHandler = null)
     {
-        return When::resolve($promisesOrValues)->then(function ($array) use ($howMany, $fulfilledHandler, $errorHandler, $progressHandler) {
-            if (!is_array($array)) {
-                $array = array();
-            }
-
-            $len       = count($array);
-            $toResolve = max(0, min($howMany, $len));
-            $values    = array();
-            $deferred  = new Deferred();
-
-            if (!$toResolve) {
-                $deferred->resolve($values);
-            } else {
-                $toReject = ($len - $toResolve) + 1;
-                $reasons  = array();
-
-                $progress = array($deferred, 'progress');
-
-                $fulfillOne = function ($val, $i) use (&$values, &$toResolve, $deferred) {
-                    $values[$i] = $val;
-
-                    if (0 === --$toResolve) {
-                        $deferred->resolve($values);
-
-                        return true;
-                    }
-                };
-
-                $rejectOne = function ($reason, $i) use (&$reasons, &$toReject, $deferred) {
-                    $reasons[$i] = $reason;
-
-                    if (0 === --$toReject) {
-                        $deferred->reject($reasons);
-
-                        return true;
-                    }
-                };
-
-                foreach ($array as $i => $promiseOrValue) {
-                    $fulfiller = function ($val) use ($i, &$fulfillOne, &$rejectOne) {
-                        $reset = $fulfillOne($val, $i);
-
-                        if (true === $reset) {
-                            $fulfillOne = $rejectOne = function () {};
-                        }
-                    };
-
-                    $rejecter = function ($val) use ($i, &$fulfillOne, &$rejectOne) {
-                        $reset = $rejectOne($val, $i);
-
-                        if (true === $reset) {
-                            $fulfillOne = $rejectOne = function () {};
-                        }
-                    };
-
-                    When::resolve($promiseOrValue)->then($fulfiller, $rejecter, $progress);
-                }
-            }
-
-            return $deferred->then($fulfilledHandler, $errorHandler, $progressHandler);
-        });
+        return some($promisesOrValues, $howMany)->then($fulfilledHandler, $errorHandler, $progressHandler);
     }
 
     public static function map($promisesOrValues, $mapFunc)
     {
-        return When::resolve($promisesOrValues)->then(function ($array) use ($mapFunc) {
-            if (!is_array($array)) {
-                $array = array();
-            }
-
-            $toResolve = count($array);
-            $results   = array();
-            $deferred  = new Deferred();
-
-            if (!$toResolve) {
-                $deferred->resolve($results);
-            } else {
-                $resolve = function ($item, $i) use ($mapFunc, &$results, &$toResolve, $deferred) {
-                    When::resolve($item)
-                        ->then($mapFunc)
-                        ->then(
-                            function ($mapped) use (&$results, $i, &$toResolve, $deferred) {
-                                $results[$i] = $mapped;
-
-                                if (0 === --$toResolve) {
-                                    $deferred->resolve($results);
-                                }
-                            },
-                            array($deferred, 'reject')
-                        );
-                };
-
-                foreach ($array as $i => $item) {
-                    $resolve($item, $i);
-                }
-            }
-
-            return $deferred->promise();
-        });
+        return map($promisesOrValues, $mapFunc);
     }
 
     public static function reduce($promisesOrValues, $reduceFunc , $initialValue = null)
     {
-        return When::resolve($promisesOrValues)->then(function ($array) use ($reduceFunc, $initialValue) {
-            if (!is_array($array)) {
-                $array = array();
-            }
-
-            $total = count($array);
-            $i = 0;
-
-            // Wrap the supplied $reduceFunc with one that handles promises and then
-            // delegates to the supplied.
-            $wrappedReduceFunc = function ($current, $val) use ($reduceFunc, $total, &$i) {
-                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);
-                    });
-                });
-            };
-
-            return array_reduce($array, $wrappedReduceFunc, $initialValue);
-        });
+        return reduce($promisesOrValues, $reduceFunc, $initialValue);
     }
 }