Initial implementations of series() and parallel()

Author: igorw

.gitignore

@@ -0,0 +1 @@
+vendor

.travis.yml

@@ -0,0 +1,11 @@
+language: php
+
+php:
+  - 5.3
+  - 5.4
+
+before_script:
+  - curl -s http://getcomposer.org/installer | php
+  - php composer.phar install
+
+script: phpunit --coverage-text

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Igor Wiedler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,33 @@
+# React-Async
+
+Async utilities for React.
+
+It is heavily based on [async.js](https://github.com/caolan/async).
+
+[![Build Status](https://secure.travis-ci.org/react-php/async.png?branch=master)](http://travis-ci.org/react-php/zmq)
+
+## Install
+
+The recommended way to install react/async is [through composer](http://getcomposer.org).
+
+```JSON
+{
+    "require": {
+        "react/zmq": "dev-master"
+    }
+}
+```
+
+## Example
+
+
+
+## Tests
+
+To run the test suite, you need PHPUnit.
+
+    $ phpunit
+
+## License
+
+MIT, see LICENSE.

composer.json

@@ -0,0 +1,15 @@
+{
+    "name": "react/async",
+    "description": "Async utilities for React.",
+    "keywords": ["async"],
+    "license": "MIT",
+    "require": {
+        "php": ">=5.3.2"
+    },
+    "require-dev": {
+        "react/event-loop": "dev-master"
+    },
+    "autoload": {
+        "psr-0": { "React\\Async": "src" }
+    }
+}

composer.lock

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false"
+         bootstrap="tests/bootstrap.php"
+>
+    <testsuites>
+        <testsuite name="React-Async Test Suite">
+            <directory>./tests/React/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./src/</directory>
+        </whitelist>
+    </filter>
+</phpunit>

phpunit.xml.dist

@@ -0,0 +1,74 @@
+<?php
+
+namespace React\Async;
+
+class Util
+{
+    public static function series($tasks, $callback, $errback)
+    {
+        $results = array();
+
+        $taskCallback = function ($result) use (&$results, &$next) {
+            $results[] = $result;
+            $next();
+        };
+
+        $done = function () use (&$results, $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();
+    }
+
+    public static function parallel($tasks, $callback, $errback)
+    {
+        $results = array();
+        $errors = array();
+
+        $taskErrback = function ($error) use (&$errors, &$checkDone) {
+            $errors[] = $error;
+            $checkDone();
+        };
+
+        $done = function () use (&$results, &$errors, $callback, $errback) {
+            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);
+        }
+    }
+}

src/React/Async/Util.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace React\Tests\Async;
+
+class TestCase extends \PHPUnit_Framework_TestCase
+{
+    protected function createCallableMock($expects, $with = null)
+    {
+        $callable = $this->getMock('React\Tests\Async\CallableStub');
+
+        $method = $callable
+            ->expects($expects)
+            ->method('__invoke');
+
+        if ($with) {
+            $method->with($with);
+        }
+
+        return $callable;
+    }
+}
+
+class CallableStub
+{
+    public function __invoke()
+    {
+    }
+}

tests/React/Tests/Async/TestCase.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace React\Tests\Async;
+
+class Timer
+{
+    private $testCase;
+    private $start;
+    private $stop;
+
+    public function __construct(TestCase $testCase)
+    {
+        $this->testCase = $testCase;
+    }
+
+    public function start()
+    {
+        $this->start = microtime(true);
+    }
+
+    public function stop()
+    {
+        $this->stop = microtime(true);
+    }
+
+    public function getInterval()
+    {
+        return $this->stop - $this->start;
+    }
+
+    public function assertLessThan($milliseconds)
+    {
+        $this->testCase->assertLessThan($milliseconds, $this->getInterval());
+    }
+
+    public function assertGreaterThan($milliseconds)
+    {
+        $this->testCase->assertGreaterThan($milliseconds, $this->getInterval());
+    }
+
+    public function assertInRange($minMs, $maxMs)
+    {
+        $this->assertGreaterThan($minMs);
+        $this->assertLessThan($maxMs);
+    }
+}