Change to use functional API instead of static Util class

Author: clue

README.md

@@ -25,24 +25,48 @@ whatsoever!*
 **Table of Contents**
 
 * [Usage](#usage)
-    * [Parallel](#parallel)
-    * [Waterfall](#waterfall)
+    * [parallel()](#parallel)
+    * [waterfall()](#waterfall)
 * [Todo](#todo)
 * [Install](#install)
 * [Tests](#tests)
 * [License](#license)
 
 ## Usage
 
-### Parallel
+This lightweight library consists only of a few simple functions.
+All functions reside under the `React\Async` namespace.
+
+The below examples refer to all functions with their fully-qualified names like this:
+
+```php
+React\Async\parallel(…);
+```
+
+As of PHP 5.6+ you can also import each required function into your code like this:
+
+```php
+use function React\Async\parallel;
+
+parallel(…);
+```
+
+Alternatively, you can also use an import statement similar to this:
+
+```php
+use React\Async;
+
+Async\parallel(…);
+```
+
+### parallel()
 
 ```php
 <?php
 
-use React\Async\Util as Async;
 use React\EventLoop\Loop;
 
-Async::parallel(
+React\Async\parallel(
     array(
         function ($callback, $errback) {
             Loop::addTimer(1, function () use ($callback) {
@@ -71,12 +95,11 @@ Async::parallel(
 );
 ```
 
-### Waterfall
+### waterfall()
 
 ```php
 <?php
 
-use React\Async\Util as Async;
 use React\EventLoop\Loop;
 
 $addOne = function ($prev, $callback = null) {
@@ -90,7 +113,7 @@ $addOne = function ($prev, $callback = null) {
     });
 };
 
-Async::waterfall(array(
+React\Async\waterfall(array(
     $addOne,
     $addOne,
     $addOne,

composer.json

@@ -36,7 +36,9 @@
         "react/event-loop": "You need an event loop for this to make sense."
     },
     "autoload": {
-        "psr-4": { "React\\Async\\": "src/" }
+        "files": [
+            "src/functions_include.php"
+        ]
     },
     "autoload-dev": {
         "psr-4": { "React\\Tests\\Async\\": "tests/" }

src/Util.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace React\Async;
+
+function parallel($tasks, $callback = null, $errback = null)
+{
+    $results = array();
+    $errors = array();
+
+    $taskErrback = function ($error) use (&$errors, &$checkDone) {
+        $errors[] = $error;
+        $checkDone();
+    };
+
+    $done = function () use (&$results, &$errors, $callback, $errback) {
+        if (!$callback) {
+            return;
+        }
+
+        if (count($errors)) {
+            $errback(array_shift($errors));
+            return;
+        }
+
+        $callback($results);
+    };
+
+    $numTasks = count($tasks);
+
+    if (0 === $numTasks) {
+        $done();
+        return;
+    }
+
+    $checkDone = function () use (&$results, &$errors, $numTasks, $done) {
+        if ($numTasks === count($results) + count($errors)) {
+            $done();
+        }
+    };
+
+    foreach ($tasks as $i => $task) {
+        $taskCallback = function ($result) use (&$results, $i, $checkDone) {
+            $results[$i] = $result;
+            $checkDone();
+        };
+
+        call_user_func($task, $taskCallback, $taskErrback);
+    }
+}
+
+function series($tasks, $callback = null, $errback = null)
+{
+    $results = array();
+
+    $taskCallback = function ($result) use (&$results, &$next) {
+        $results[] = $result;
+        $next();
+    };
+
+    $done = function () use (&$results, $callback) {
+        if ($callback) {
+            call_user_func($callback, $results);
+        }
+    };
+
+    $next = function () use (&$tasks, $taskCallback, $errback, $done) {
+        if (0 === count($tasks)) {
+            $done();
+            return;
+        }
+
+        $task = array_shift($tasks);
+        call_user_func($task, $taskCallback, $errback);
+    };
+
+    $next();
+}
+
+function waterfall($tasks, $callback = null, $errback = null)
+{
+    $taskCallback = function () use (&$next) {
+        call_user_func_array($next, func_get_args());
+    };
+
+    $done = function () use ($callback) {
+        if ($callback) {
+            call_user_func_array($callback, func_get_args());
+        }
+    };
+
+    $next = function () use (&$tasks, $taskCallback, $errback, $done) {
+        if (0 === count($tasks)) {
+            call_user_func_array($done, func_get_args());
+            return;
+        }
+
+        $task = array_shift($tasks);
+        $args = array_merge(func_get_args(), array($taskCallback, $errback));
+        call_user_func_array($task, $args);
+    };
+
+    $next();
+}

src/functions.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace React\Async;
+
+// @codeCoverageIgnoreStart
+if (!function_exists(__NAMESPACE__ . '\\parallel')) {
+    require __DIR__ . '/functions.php';
+}

src/functions_include.php

@@ -2,10 +2,10 @@
 
 namespace React\Tests\Async;
 
-use React\Async\Util;
+use React;
 use React\EventLoop\Loop;
 
-class UtilParallelTest extends TestCase
+class ParallelTest extends TestCase
 {
     public function testParallelWithoutTasks()
     {
@@ -14,7 +14,7 @@ public function testParallelWithoutTasks()
         $callback = $this->expectCallableOnceWith(array());
         $errback = $this->expectCallableNever();
 
-        Util::parallel($tasks, $callback, $errback);
+        React\Async\parallel($tasks, $callback, $errback);
     }
 
     public function testParallelWithTasks()
@@ -35,7 +35,7 @@ function ($callback, $errback) {
         $callback = $this->expectCallableOnceWith(array('foo', 'bar'));
         $errback = $this->expectCallableNever();
 
-        Util::parallel($tasks, $callback, $errback);
+        React\Async\parallel($tasks, $callback, $errback);
 
         $timer = new Timer($this);
         $timer->start();
@@ -68,7 +68,7 @@ function ($callback, $errback) use (&$called) {
         $callback = $this->expectCallableNever();
         $errback = $this->expectCallableOnce();
 
-        Util::parallel($tasks, $callback, $errback);
+        React\Async\parallel($tasks, $callback, $errback);
 
         $this->assertSame(2, $called);
     }
@@ -97,7 +97,7 @@ function ($callback, $errback) use (&$called) {
         $callback = $this->expectCallableNever();
         $errback = $this->expectCallableOnce();
 
-        Util::parallel($tasks, $callback, $errback);
+        React\Async\parallel($tasks, $callback, $errback);
 
         Loop::run();
 

tests/UtilParallelTest.php renamed to tests/ParallelTest.php

@@ -2,10 +2,10 @@
 
 namespace React\Tests\Async;
 
-use React\Async\Util;
+use React;
 use React\EventLoop\Loop;
 
-class UtilSeriesTest extends TestCase
+class SeriesTest extends TestCase
 {
     public function testSeriesWithoutTasks()
     {
@@ -14,7 +14,7 @@ public function testSeriesWithoutTasks()
         $callback = $this->expectCallableOnceWith(array());
         $errback = $this->expectCallableNever();
 
-        Util::series($tasks, $callback, $errback);
+        React\Async\series($tasks, $callback, $errback);
     }
 
     public function testSeriesWithTasks()
@@ -35,7 +35,7 @@ function ($callback, $errback) {
         $callback = $this->expectCallableOnceWith(array('foo', 'bar'));
         $errback = $this->expectCallableNever();
 
-        Util::series($tasks, $callback, $errback);
+        React\Async\series($tasks, $callback, $errback);
 
         $timer = new Timer($this);
         $timer->start();
@@ -68,7 +68,7 @@ function ($callback, $errback) use (&$called) {
         $callback = $this->expectCallableNever();
         $errback = $this->expectCallableOnce();
 
-        Util::series($tasks, $callback, $errback);
+        React\Async\series($tasks, $callback, $errback);
 
         $this->assertSame(1, $called);
     }