RubyGems - hooch - Versions diffs - 0.4.2 → 0.4.3 - Mend

hooch 0.4.2 → 0.4.3

Files changed (3209) hide show

data/jasmine/node_modules/karma-phantomjs-launcher/node_modules/phantomjs/node_modules/request/node_modules/form-data/node_modules/async/.travis.yml DELETED Viewed

@@ -1,3 +0,0 @@
-language: node_js
-node_js:
-  - "0.10"

data/jasmine/node_modules/karma-phantomjs-launcher/node_modules/phantomjs/node_modules/request/node_modules/form-data/node_modules/async/LICENSE DELETED Viewed

@@ -1,19 +0,0 @@
-Copyright (c) 2010-2014 Caolan McMahon
-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.

data/jasmine/node_modules/karma-phantomjs-launcher/node_modules/phantomjs/node_modules/request/node_modules/form-data/node_modules/async/README.md DELETED Viewed

@@ -1,1646 +0,0 @@
-# Async.js
-[![Build Status via Travis CI](https://travis-ci.org/caolan/async.svg?branch=master)](https://travis-ci.org/caolan/async)
-Async is a utility module which provides straight-forward, powerful functions
-for working with asynchronous JavaScript. Although originally designed for
-use with [Node.js](http://nodejs.org), it can also be used directly in the
-browser. Also supports [component](https://github.com/component/component).
-Async provides around 20 functions that include the usual 'functional'
-suspects (`map`, `reduce`, `filter`, `each`…) as well as some common patterns
-for asynchronous control flow (`parallel`, `series`, `waterfall`…). All these
-functions assume you follow the Node.js convention of providing a single
-callback as the last argument of your `async` function.
-## Quick Examples
-```javascript
-async.map(['file1','file2','file3'], fs.stat, function(err, results){
-    // results is now an array of stats for each file
-});
-async.filter(['file1','file2','file3'], fs.exists, function(results){
-    // results now equals an array of the existing files
-});
-async.parallel([
-    function(){ ... },
-    function(){ ... }
-], callback);
-async.series([
-    function(){ ... },
-    function(){ ... }
-]);
-```
-There are many more functions available so take a look at the docs below for a
-full list. This module aims to be comprehensive, so if you feel anything is
-missing please create a GitHub issue for it.
-## Common Pitfalls
-### Binding a context to an iterator
-This section is really about `bind`, not about `async`. If you are wondering how to
-make `async` execute your iterators in a given context, or are confused as to why
-a method of another library isn't working as an iterator, study this example:
-```js
-// Here is a simple object with an (unnecessarily roundabout) squaring method
-var AsyncSquaringLibrary = {
-  squareExponent: 2,
-  square: function(number, callback){
-    var result = Math.pow(number, this.squareExponent);
-    setTimeout(function(){
-      callback(null, result);
-    }, 200);
-  }
-};
-async.map([1, 2, 3], AsyncSquaringLibrary.square, function(err, result){
-  // result is [NaN, NaN, NaN]
-  // This fails because the `this.squareExponent` expression in the square
-  // function is not evaluated in the context of AsyncSquaringLibrary, and is
-  // therefore undefined.
-});
-async.map([1, 2, 3], AsyncSquaringLibrary.square.bind(AsyncSquaringLibrary), function(err, result){
-  // result is [1, 4, 9]
-  // With the help of bind we can attach a context to the iterator before
-  // passing it to async. Now the square function will be executed in its
-  // 'home' AsyncSquaringLibrary context and the value of `this.squareExponent`
-  // will be as expected.
-});
-```
-## Download
-The source is available for download from
-[GitHub](http://github.com/caolan/async).
-Alternatively, you can install using Node Package Manager (`npm`):
-    npm install async
-__Development:__ [async.js](https://github.com/caolan/async/raw/master/lib/async.js) - 29.6kb Uncompressed
-## In the Browser
-So far it's been tested in IE6, IE7, IE8, FF3.6 and Chrome 5.
-Usage:
-```html
-<script type="text/javascript" src="async.js"></script>
-<script type="text/javascript">
-    async.map(data, asyncProcess, function(err, results){
-        alert(results);
-    });
-</script>
-```
-## Documentation
-### Collections
-* [`each`](#each)
-* [`eachSeries`](#eachSeries)
-* [`eachLimit`](#eachLimit)
-* [`map`](#map)
-* [`mapSeries`](#mapSeries)
-* [`mapLimit`](#mapLimit)
-* [`filter`](#filter)
-* [`filterSeries`](#filterSeries)
-* [`reject`](#reject)
-* [`rejectSeries`](#rejectSeries)
-* [`reduce`](#reduce)
-* [`reduceRight`](#reduceRight)
-* [`detect`](#detect)
-* [`detectSeries`](#detectSeries)
-* [`sortBy`](#sortBy)
-* [`some`](#some)
-* [`every`](#every)
-* [`concat`](#concat)
-* [`concatSeries`](#concatSeries)
-### Control Flow
-* [`series`](#seriestasks-callback)
-* [`parallel`](#parallel)
-* [`parallelLimit`](#parallellimittasks-limit-callback)
-* [`whilst`](#whilst)
-* [`doWhilst`](#doWhilst)
-* [`until`](#until)
-* [`doUntil`](#doUntil)
-* [`forever`](#forever)
-* [`waterfall`](#waterfall)
-* [`compose`](#compose)
-* [`seq`](#seq)
-* [`applyEach`](#applyEach)
-* [`applyEachSeries`](#applyEachSeries)
-* [`queue`](#queue)
-* [`priorityQueue`](#priorityQueue)
-* [`cargo`](#cargo)
-* [`auto`](#auto)
-* [`retry`](#retry)
-* [`iterator`](#iterator)
-* [`apply`](#apply)
-* [`nextTick`](#nextTick)
-* [`times`](#times)
-* [`timesSeries`](#timesSeries)
-### Utils
-* [`memoize`](#memoize)
-* [`unmemoize`](#unmemoize)
-* [`log`](#log)
-* [`dir`](#dir)
-* [`noConflict`](#noConflict)
-## Collections
-<a name="forEach" />
-<a name="each" />
-### each(arr, iterator, callback)
-Applies the function `iterator` to each item in `arr`, in parallel.
-The `iterator` is called with an item from the list, and a callback for when it
-has finished. If the `iterator` passes an error to its `callback`, the main
-`callback` (for the `each` function) is immediately called with the error.
-Note, that since this function applies `iterator` to each item in parallel,
-there is no guarantee that the iterator functions will complete in order.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A function to apply to each item in `arr`.
-  The iterator is passed a `callback(err)` which must be called once it has
-  completed. If no error has occured, the `callback` should be run without
-  arguments or with an explicit `null` argument.
-* `callback(err)` - A callback which is called when all `iterator` functions
-  have finished, or an error occurs.
-__Examples__
-```js
-// assuming openFiles is an array of file names and saveFile is a function
-// to save the modified contents of that file:
-async.each(openFiles, saveFile, function(err){
-    // if any of the saves produced an error, err would equal that error
-});
-```
-```js
-// assuming openFiles is an array of file names
-async.each(openFiles, function( file, callback) {
-  // Perform operation on file here.
-  console.log('Processing file ' + file);
-  if( file.length > 32 ) {
-    console.log('This file name is too long');
-    callback('File name too long');
-  } else {
-    // Do work to process file here
-    console.log('File processed');
-    callback();
-  }
-}, function(err){
-    // if any of the file processing produced an error, err would equal that error
-    if( err ) {
-      // One of the iterations produced an error.
-      // All processing will now stop.
-      console.log('A file failed to process');
-    } else {
-      console.log('All files have been processed successfully');
-    }
-});
-```
----------------------------------------
-<a name="forEachSeries" />
-<a name="eachSeries" />
-### eachSeries(arr, iterator, callback)
-The same as [`each`](#each), only `iterator` is applied to each item in `arr` in
-series. The next `iterator` is only called once the current one has completed.
-This means the `iterator` functions will complete in order.
----------------------------------------
-<a name="forEachLimit" />
-<a name="eachLimit" />
-### eachLimit(arr, limit, iterator, callback)
-The same as [`each`](#each), only no more than `limit` `iterator`s will be simultaneously
-running at any time.
-Note that the items in `arr` are not processed in batches, so there is no guarantee that
-the first `limit` `iterator` functions will complete before any others are started.
-__Arguments__
-* `arr` - An array to iterate over.
-* `limit` - The maximum number of `iterator`s to run at any time.
-* `iterator(item, callback)` - A function to apply to each item in `arr`.
-  The iterator is passed a `callback(err)` which must be called once it has
-  completed. If no error has occured, the callback should be run without
-  arguments or with an explicit `null` argument.
-* `callback(err)` - A callback which is called when all `iterator` functions
-  have finished, or an error occurs.
-__Example__
-```js
-// Assume documents is an array of JSON objects and requestApi is a
-// function that interacts with a rate-limited REST api.
-async.eachLimit(documents, 20, requestApi, function(err){
-    // if any of the saves produced an error, err would equal that error
-});
-```
----------------------------------------
-<a name="map" />
-### map(arr, iterator, callback)
-Produces a new array of values by mapping each value in `arr` through
-the `iterator` function. The `iterator` is called with an item from `arr` and a
-callback for when it has finished processing. Each of these callback takes 2 arguments:
-an `error`, and the transformed item from `arr`. If `iterator` passes an error to this
-callback, the main `callback` (for the `map` function) is immediately called with the error.
-Note, that since this function applies the `iterator` to each item in parallel,
-there is no guarantee that the `iterator` functions will complete in order.
-However, the results array will be in the same order as the original `arr`.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A function to apply to each item in `arr`.
-  The iterator is passed a `callback(err, transformed)` which must be called once
-  it has completed with an error (which can be `null`) and a transformed item.
-* `callback(err, results)` - A callback which is called when all `iterator`
-  functions have finished, or an error occurs. Results is an array of the
-  transformed items from the `arr`.
-__Example__
-```js
-async.map(['file1','file2','file3'], fs.stat, function(err, results){
-    // results is now an array of stats for each file
-});
-```
----------------------------------------
-<a name="mapSeries" />
-### mapSeries(arr, iterator, callback)
-The same as [`map`](#map), only the `iterator` is applied to each item in `arr` in
-series. The next `iterator` is only called once the current one has completed.
-The results array will be in the same order as the original.
----------------------------------------
-<a name="mapLimit" />
-### mapLimit(arr, limit, iterator, callback)
-The same as [`map`](#map), only no more than `limit` `iterator`s will be simultaneously
-running at any time.
-Note that the items are not processed in batches, so there is no guarantee that
-the first `limit` `iterator` functions will complete before any others are started.
-__Arguments__
-* `arr` - An array to iterate over.
-* `limit` - The maximum number of `iterator`s to run at any time.
-* `iterator(item, callback)` - A function to apply to each item in `arr`.
-  The iterator is passed a `callback(err, transformed)` which must be called once
-  it has completed with an error (which can be `null`) and a transformed item.
-* `callback(err, results)` - A callback which is called when all `iterator`
-  calls have finished, or an error occurs. The result is an array of the
-  transformed items from the original `arr`.
-__Example__
-```js
-async.mapLimit(['file1','file2','file3'], 1, fs.stat, function(err, results){
-    // results is now an array of stats for each file
-});
-```
----------------------------------------
-<a name="select" />
-<a name="filter" />
-### filter(arr, iterator, callback)
-__Alias:__ `select`
-Returns a new array of all the values in `arr` which pass an async truth test.
-_The callback for each `iterator` call only accepts a single argument of `true` or
-`false`; it does not accept an error argument first!_ This is in-line with the
-way node libraries work with truth tests like `fs.exists`. This operation is
-performed in parallel, but the results array will be in the same order as the
-original.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A truth test to apply to each item in `arr`.
-  The `iterator` is passed a `callback(truthValue)`, which must be called with a
-  boolean argument once it has completed.
-* `callback(results)` - A callback which is called after all the `iterator`
-  functions have finished.
-__Example__
-```js
-async.filter(['file1','file2','file3'], fs.exists, function(results){
-    // results now equals an array of the existing files
-});
-```
----------------------------------------
-<a name="selectSeries" />
-<a name="filterSeries" />
-### filterSeries(arr, iterator, callback)
-__Alias:__ `selectSeries`
-The same as [`filter`](#filter) only the `iterator` is applied to each item in `arr` in
-series. The next `iterator` is only called once the current one has completed.
-The results array will be in the same order as the original.
----------------------------------------
-<a name="reject" />
-### reject(arr, iterator, callback)
-The opposite of [`filter`](#filter). Removes values that pass an `async` truth test.
----------------------------------------
-<a name="rejectSeries" />
-### rejectSeries(arr, iterator, callback)
-The same as [`reject`](#reject), only the `iterator` is applied to each item in `arr`
-in series.
----------------------------------------
-<a name="reduce" />
-### reduce(arr, memo, iterator, callback)
-__Aliases:__ `inject`, `foldl`
-Reduces `arr` into a single value using an async `iterator` to return
-each successive step. `memo` is the initial state of the reduction.
-This function only operates in series.
-For performance reasons, it may make sense to split a call to this function into
-a parallel map, and then use the normal `Array.prototype.reduce` on the results.
-This function is for situations where each step in the reduction needs to be async;
-if you can get the data before reducing it, then it's probably a good idea to do so.
-__Arguments__
-* `arr` - An array to iterate over.
-* `memo` - The initial state of the reduction.
-* `iterator(memo, item, callback)` - A function applied to each item in the
-  array to produce the next step in the reduction. The `iterator` is passed a
-  `callback(err, reduction)` which accepts an optional error as its first
-  argument, and the state of the reduction as the second. If an error is
-  passed to the callback, the reduction is stopped and the main `callback` is
-  immediately called with the error.
-* `callback(err, result)` - A callback which is called after all the `iterator`
-  functions have finished. Result is the reduced value.
-__Example__
-```js
-async.reduce([1,2,3], 0, function(memo, item, callback){
-    // pointless async:
-    process.nextTick(function(){
-        callback(null, memo + item)
-    });
-}, function(err, result){
-    // result is now equal to the last value of memo, which is 6
-});
-```
----------------------------------------
-<a name="reduceRight" />
-### reduceRight(arr, memo, iterator, callback)
-__Alias:__ `foldr`
-Same as [`reduce`](#reduce), only operates on `arr` in reverse order.
----------------------------------------
-<a name="detect" />
-### detect(arr, iterator, callback)
-Returns the first value in `arr` that passes an async truth test. The
-`iterator` is applied in parallel, meaning the first iterator to return `true` will
-fire the detect `callback` with that result. That means the result might not be
-the first item in the original `arr` (in terms of order) that passes the test.
-If order within the original `arr` is important, then look at [`detectSeries`](#detectSeries).
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A truth test to apply to each item in `arr`.
-  The iterator is passed a `callback(truthValue)` which must be called with a
-  boolean argument once it has completed.
-* `callback(result)` - A callback which is called as soon as any iterator returns
-  `true`, or after all the `iterator` functions have finished. Result will be
-  the first item in the array that passes the truth test (iterator) or the
-  value `undefined` if none passed.
-__Example__
-```js
-async.detect(['file1','file2','file3'], fs.exists, function(result){
-    // result now equals the first file in the list that exists
-});
-```
----------------------------------------
-<a name="detectSeries" />
-### detectSeries(arr, iterator, callback)
-The same as [`detect`](#detect), only the `iterator` is applied to each item in `arr`
-in series. This means the result is always the first in the original `arr` (in
-terms of array order) that passes the truth test.
----------------------------------------
-<a name="sortBy" />
-### sortBy(arr, iterator, callback)
-Sorts a list by the results of running each `arr` value through an async `iterator`.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A function to apply to each item in `arr`.
-  The iterator is passed a `callback(err, sortValue)` which must be called once it
-  has completed with an error (which can be `null`) and a value to use as the sort
-  criteria.
-* `callback(err, results)` - A callback which is called after all the `iterator`
-  functions have finished, or an error occurs. Results is the items from
-  the original `arr` sorted by the values returned by the `iterator` calls.
-__Example__
-```js
-async.sortBy(['file1','file2','file3'], function(file, callback){
-    fs.stat(file, function(err, stats){
-        callback(err, stats.mtime);
-    });
-}, function(err, results){
-    // results is now the original array of files sorted by
-    // modified date
-});
-```
-__Sort Order__
-By modifying the callback parameter the sorting order can be influenced:
-```js
-//ascending order
-async.sortBy([1,9,3,5], function(x, callback){
-    callback(err, x);
-}, function(err,result){
-    //result callback
-} );
-//descending order
-async.sortBy([1,9,3,5], function(x, callback){
-    callback(err, x*-1);    //<- x*-1 instead of x, turns the order around
-}, function(err,result){
-    //result callback
-} );
-```
----------------------------------------
-<a name="some" />
-### some(arr, iterator, callback)
-__Alias:__ `any`
-Returns `true` if at least one element in the `arr` satisfies an async test.
-_The callback for each iterator call only accepts a single argument of `true` or
-`false`; it does not accept an error argument first!_ This is in-line with the
-way node libraries work with truth tests like `fs.exists`. Once any iterator
-call returns `true`, the main `callback` is immediately called.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A truth test to apply to each item in the array
-  in parallel. The iterator is passed a callback(truthValue) which must be
-  called with a boolean argument once it has completed.
-* `callback(result)` - A callback which is called as soon as any iterator returns
-  `true`, or after all the iterator functions have finished. Result will be
-  either `true` or `false` depending on the values of the async tests.
-__Example__
-```js
-async.some(['file1','file2','file3'], fs.exists, function(result){
-    // if result is true then at least one of the files exists
-});
-```
----------------------------------------
-<a name="every" />
-### every(arr, iterator, callback)
-__Alias:__ `all`
-Returns `true` if every element in `arr` satisfies an async test.
-_The callback for each `iterator` call only accepts a single argument of `true` or
-`false`; it does not accept an error argument first!_ This is in-line with the
-way node libraries work with truth tests like `fs.exists`.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A truth test to apply to each item in the array
-  in parallel. The iterator is passed a callback(truthValue) which must be
-  called with a  boolean argument once it has completed.
-* `callback(result)` - A callback which is called after all the `iterator`
-  functions have finished. Result will be either `true` or `false` depending on
-  the values of the async tests.
-__Example__
-```js
-async.every(['file1','file2','file3'], fs.exists, function(result){
-    // if result is true then every file exists
-});
-```
----------------------------------------
-<a name="concat" />
-### concat(arr, iterator, callback)
-Applies `iterator` to each item in `arr`, concatenating the results. Returns the
-concatenated list. The `iterator`s are called in parallel, and the results are
-concatenated as they return. There is no guarantee that the results array will
-be returned in the original order of `arr` passed to the `iterator` function.
-__Arguments__
-* `arr` - An array to iterate over.
-* `iterator(item, callback)` - A function to apply to each item in `arr`.
-  The iterator is passed a `callback(err, results)` which must be called once it
-  has completed with an error (which can be `null`) and an array of results.
-* `callback(err, results)` - A callback which is called after all the `iterator`
-  functions have finished, or an error occurs. Results is an array containing
-  the concatenated results of the `iterator` function.
-__Example__
-```js
-async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files){
-    // files is now a list of filenames that exist in the 3 directories
-});
-```
----------------------------------------
-<a name="concatSeries" />
-### concatSeries(arr, iterator, callback)
-Same as [`concat`](#concat), but executes in series instead of parallel.
-## Control Flow
-<a name="series" />
-### series(tasks, [callback])
-Run the functions in the `tasks` array in series, each one running once the previous
-function has completed. If any functions in the series pass an error to its
-callback, no more functions are run, and `callback` is immediately called with the value of the error.
-Otherwise, `callback` receives an array of results when `tasks` have completed.
-It is also possible to use an object instead of an array. Each property will be
-run as a function, and the results will be passed to the final `callback` as an object
-instead of an array. This can be a more readable way of handling results from
-[`series`](#series).
-**Note** that while many implementations preserve the order of object properties, the
-[ECMAScript Language Specifcation](http://www.ecma-international.org/ecma-262/5.1/#sec-8.6)
-explicitly states that
-> The mechanics and order of enumerating the properties is not specified.
-So if you rely on the order in which your series of functions are executed, and want
-this to work on all platforms, consider using an array.
-__Arguments__
-* `tasks` - An array or object containing functions to run, each function is passed
-  a `callback(err, result)` it must call on completion with an error `err` (which can
-  be `null`) and an optional `result` value.
-* `callback(err, results)` - An optional callback to run once all the functions
-  have completed. This function gets a results array (or object) containing all
-  the result arguments passed to the `task` callbacks.
-__Example__
-```js
-async.series([
-    function(callback){
-        // do some stuff ...
-        callback(null, 'one');
-    },
-    function(callback){
-        // do some more stuff ...
-        callback(null, 'two');
-    }
-],
-// optional callback
-function(err, results){
-    // results is now equal to ['one', 'two']
-});
-// an example using an object instead of an array
-async.series({
-    one: function(callback){
-        setTimeout(function(){
-            callback(null, 1);
-        }, 200);
-    },
-    two: function(callback){
-        setTimeout(function(){
-            callback(null, 2);
-        }, 100);
-    }
-},
-function(err, results) {
-    // results is now equal to: {one: 1, two: 2}
-});
-```
----------------------------------------
-<a name="parallel" />
-### parallel(tasks, [callback])
-Run the `tasks` array of functions in parallel, without waiting until the previous
-function has completed. If any of the functions pass an error to its
-callback, the main `callback` is immediately called with the value of the error.
-Once the `tasks` have completed, the results are passed to the final `callback` as an
-array.
-It is also possible to use an object instead of an array. Each property will be
-run as a function and the results will be passed to the final `callback` as an object
-instead of an array. This can be a more readable way of handling results from
-[`parallel`](#parallel).
-__Arguments__
-* `tasks` - An array or object containing functions to run. Each function is passed
-  a `callback(err, result)` which it must call on completion with an error `err`
-  (which can be `null`) and an optional `result` value.
-* `callback(err, results)` - An optional callback to run once all the functions
-  have completed. This function gets a results array (or object) containing all
-  the result arguments passed to the task callbacks.
-__Example__
-```js
-async.parallel([
-    function(callback){
-        setTimeout(function(){
-            callback(null, 'one');
-        }, 200);
-    },
-    function(callback){
-        setTimeout(function(){
-            callback(null, 'two');
-        }, 100);
-    }
-],
-// optional callback
-function(err, results){
-    // the results array will equal ['one','two'] even though
-    // the second function had a shorter timeout.
-});
-// an example using an object instead of an array
-async.parallel({
-    one: function(callback){
-        setTimeout(function(){
-            callback(null, 1);
-        }, 200);
-    },
-    two: function(callback){
-        setTimeout(function(){
-            callback(null, 2);
-        }, 100);
-    }
-},
-function(err, results) {
-    // results is now equals to: {one: 1, two: 2}
-});
-```
----------------------------------------
-<a name="parallelLimit" />
-### parallelLimit(tasks, limit, [callback])
-The same as [`parallel`](#parallel), only `tasks` are executed in parallel
-with a maximum of `limit` tasks executing at any time.
-Note that the `tasks` are not executed in batches, so there is no guarantee that
-the first `limit` tasks will complete before any others are started.
-__Arguments__
-* `tasks` - An array or object containing functions to run, each function is passed
-  a `callback(err, result)` it must call on completion with an error `err` (which can
-  be `null`) and an optional `result` value.
-* `limit` - The maximum number of `tasks` to run at any time.
-* `callback(err, results)` - An optional callback to run once all the functions
-  have completed. This function gets a results array (or object) containing all
-  the result arguments passed to the `task` callbacks.
----------------------------------------
-<a name="whilst" />
-### whilst(test, fn, callback)
-Repeatedly call `fn`, while `test` returns `true`. Calls `callback` when stopped,
-or an error occurs.
-__Arguments__
-* `test()` - synchronous truth test to perform before each execution of `fn`.
-* `fn(callback)` - A function which is called each time `test` passes. The function is
-  passed a `callback(err)`, which must be called once it has completed with an
-  optional `err` argument.
-* `callback(err)` - A callback which is called after the test fails and repeated
-  execution of `fn` has stopped.
-__Example__
-```js
-var count = 0;
-async.whilst(
-    function () { return count < 5; },
-    function (callback) {
-        count++;
-        setTimeout(callback, 1000);
-    },
-    function (err) {
-        // 5 seconds have passed
-    }
-);
-```
----------------------------------------
-<a name="doWhilst" />
-### doWhilst(fn, test, callback)
-The post-check version of [`whilst`](#whilst). To reflect the difference in
-the order of operations, the arguments `test` and `fn` are switched.
-`doWhilst` is to `whilst` as `do while` is to `while` in plain JavaScript.
----------------------------------------
-<a name="until" />
-### until(test, fn, callback)
-Repeatedly call `fn` until `test` returns `true`. Calls `callback` when stopped,
-or an error occurs.
-The inverse of [`whilst`](#whilst).
----------------------------------------
-<a name="doUntil" />
-### doUntil(fn, test, callback)
-Like [`doWhilst`](#doWhilst), except the `test` is inverted. Note the argument ordering differs from `until`.
----------------------------------------
-<a name="forever" />
-### forever(fn, errback)
-Calls the asynchronous function `fn` with a callback parameter that allows it to
-call itself again, in series, indefinitely.
-If an error is passed to the callback then `errback` is called with the
-error, and execution stops, otherwise it will never be called.
-```js
-async.forever(
-    function(next) {
-        // next is suitable for passing to things that need a callback(err [, whatever]);
-        // it will result in this function being called again.
-    },
-    function(err) {
-        // if next is called with a value in its first parameter, it will appear
-        // in here as 'err', and execution will stop.
-    }
-);
-```
----------------------------------------
-<a name="waterfall" />
-### waterfall(tasks, [callback])
-Runs the `tasks` array of functions in series, each passing their results to the next in
-the array. However, if any of the `tasks` pass an error to their own callback, the
-next function is not executed, and the main `callback` is immediately called with
-the error.
-__Arguments__
-* `tasks` - An array of functions to run, each function is passed a
-  `callback(err, result1, result2, ...)` it must call on completion. The first
-  argument is an error (which can be `null`) and any further arguments will be
-  passed as arguments in order to the next task.
-* `callback(err, [results])` - An optional callback to run once all the functions
-  have completed. This will be passed the results of the last task's callback.
-__Example__
-```js
-async.waterfall([
-    function(callback){
-        callback(null, 'one', 'two');
-    },
-    function(arg1, arg2, callback){
-      // arg1 now equals 'one' and arg2 now equals 'two'
-        callback(null, 'three');
-    },
-    function(arg1, callback){
-        // arg1 now equals 'three'
-        callback(null, 'done');
-    }
-], function (err, result) {
-   // result now equals 'done'
-});
-```
----------------------------------------
-<a name="compose" />
-### compose(fn1, fn2...)
-Creates a function which is a composition of the passed asynchronous
-functions. Each function consumes the return value of the function that
-follows. Composing functions `f()`, `g()`, and `h()` would produce the result of
-`f(g(h()))`, only this version uses callbacks to obtain the return values.
-Each function is executed with the `this` binding of the composed function.
-__Arguments__
-* `functions...` - the asynchronous functions to compose
-__Example__
-```js
-function add1(n, callback) {
-    setTimeout(function () {
-        callback(null, n + 1);
-    }, 10);
-}
-function mul3(n, callback) {
-    setTimeout(function () {
-        callback(null, n * 3);
-    }, 10);
-}
-var add1mul3 = async.compose(mul3, add1);
-add1mul3(4, function (err, result) {
-   // result now equals 15
-});
-```
----------------------------------------
-<a name="seq" />
-### seq(fn1, fn2...)
-Version of the compose function that is more natural to read.
-Each following function consumes the return value of the latter function.
-Each function is executed with the `this` binding of the composed function.
-__Arguments__
-* functions... - the asynchronous functions to compose
-__Example__
-```js
-// Requires lodash (or underscore), express3 and dresende's orm2.
-// Part of an app, that fetches cats of the logged user.
-// This example uses `seq` function to avoid overnesting and error
-// handling clutter.
-app.get('/cats', function(request, response) {
-  function handleError(err, data, callback) {
-    if (err) {
-      console.error(err);
-      response.json({ status: 'error', message: err.message });
-    }
-    else {
-      callback(data);
-    }
-  }
-  var User = request.models.User;
-  async.seq(
-    _.bind(User.get, User),  // 'User.get' has signature (id, callback(err, data))
-    handleError,
-    function(user, fn) {
-      user.getCats(fn);      // 'getCats' has signature (callback(err, data))
-    },
-    handleError,
-    function(cats) {
-      response.json({ status: 'ok', message: 'Cats found', data: cats });
-    }
-  )(req.session.user_id);
-  }
-});
-```
----------------------------------------
-<a name="applyEach" />
-### applyEach(fns, args..., callback)
-Applies the provided arguments to each function in the array, calling
-`callback` after all functions have completed. If you only provide the first
-argument, then it will return a function which lets you pass in the
-arguments as if it were a single function call.
-__Arguments__
-* `fns` - the asynchronous functions to all call with the same arguments
-* `args...` - any number of separate arguments to pass to the function
-* `callback` - the final argument should be the callback, called when all
-  functions have completed processing
-__Example__
-```js
-async.applyEach([enableSearch, updateSchema], 'bucket', callback);
-// partial application example:
-async.each(
-    buckets,
-    async.applyEach([enableSearch, updateSchema]),
-    callback
-);
-```
----------------------------------------
-<a name="applyEachSeries" />
-### applyEachSeries(arr, iterator, callback)
-The same as [`applyEach`](#applyEach) only the functions are applied in series.
----------------------------------------
-<a name="queue" />
-### queue(worker, concurrency)
-Creates a `queue` object with the specified `concurrency`. Tasks added to the
-`queue` are processed in parallel (up to the `concurrency` limit). If all
-`worker`s are in progress, the task is queued until one becomes available.
-Once a `worker` completes a `task`, that `task`'s callback is called.
-__Arguments__
-* `worker(task, callback)` - An asynchronous function for processing a queued
-  task, which must call its `callback(err)` argument when finished, with an
-  optional `error` as an argument.
-* `concurrency` - An `integer` for determining how many `worker` functions should be
-  run in parallel.
-__Queue objects__
-The `queue` object returned by this function has the following properties and
-methods:
-* `length()` - a function returning the number of items waiting to be processed.
-* `started` - a function returning whether or not any items have been pushed and processed by the queue
-* `running()` - a function returning the number of items currently being processed.
-* `idle()` - a function returning false if there are items waiting or being processed, or true if not.
-* `concurrency` - an integer for determining how many `worker` functions should be
-  run in parallel. This property can be changed after a `queue` is created to
-  alter the concurrency on-the-fly.
-* `push(task, [callback])` - add a new task to the `queue`. Calls `callback` once
-  the `worker` has finished processing the task. Instead of a single task, a `tasks` array
-  can be submitted. The respective callback is used for every task in the list.
-* `unshift(task, [callback])` - add a new task to the front of the `queue`.
-* `saturated` - a callback that is called when the `queue` length hits the `concurrency` limit,
-   and further tasks will be queued.
-* `empty` - a callback that is called when the last item from the `queue` is given to a `worker`.
-* `drain` - a callback that is called when the last item from the `queue` has returned from the `worker`.
-* `paused` - a boolean for determining whether the queue is in a paused state
-* `pause()` - a function that pauses the processing of tasks until `resume()` is called.
-* `resume()` - a function that resumes the processing of queued tasks when the queue is paused.
-* `kill()` - a function that empties remaining tasks from the queue forcing it to go idle.
-__Example__
-```js
-// create a queue object with concurrency 2
-var q = async.queue(function (task, callback) {
-    console.log('hello ' + task.name);
-    callback();
-}, 2);
-// assign a callback
-q.drain = function() {
-    console.log('all items have been processed');
-}
-// add some items to the queue
-q.push({name: 'foo'}, function (err) {
-    console.log('finished processing foo');
-});
-q.push({name: 'bar'}, function (err) {
-    console.log('finished processing bar');
-});
-// add some items to the queue (batch-wise)
-q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function (err) {
-    console.log('finished processing bar');
-});
-// add some items to the front of the queue
-q.unshift({name: 'bar'}, function (err) {
-    console.log('finished processing bar');
-});
-```
----------------------------------------
-<a name="priorityQueue" />
-### priorityQueue(worker, concurrency)
-The same as [`queue`](#queue) only tasks are assigned a priority and completed in ascending priority order. There are two differences between `queue` and `priorityQueue` objects:
-* `push(task, priority, [callback])` - `priority` should be a number. If an array of
-  `tasks` is given, all tasks will be assigned the same priority.
-* The `unshift` method was removed.
----------------------------------------
-<a name="cargo" />
-### cargo(worker, [payload])
-Creates a `cargo` object with the specified payload. Tasks added to the
-cargo will be processed altogether (up to the `payload` limit). If the
-`worker` is in progress, the task is queued until it becomes available. Once
-the `worker` has completed some tasks, each callback of those tasks is called.
-Check out [this animation](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130382f62626330636662302d356632392d313165322d393734662d3333393763363464633835382e676966) for how `cargo` and `queue` work.
-While [queue](#queue) passes only one task to one of a group of workers
-at a time, cargo passes an array of tasks to a single worker, repeating
-when the worker is finished.
-__Arguments__
-* `worker(tasks, callback)` - An asynchronous function for processing an array of
-  queued tasks, which must call its `callback(err)` argument when finished, with
-  an optional `err` argument.
-* `payload` - An optional `integer` for determining how many tasks should be
-  processed per round; if omitted, the default is unlimited.
-__Cargo objects__
-The `cargo` object returned by this function has the following properties and
-methods:
-* `length()` - A function returning the number of items waiting to be processed.
-* `payload` - An `integer` for determining how many tasks should be
-  process per round. This property can be changed after a `cargo` is created to
-  alter the payload on-the-fly.
-* `push(task, [callback])` - Adds `task` to the `queue`. The callback is called
-  once the `worker` has finished processing the task. Instead of a single task, an array of `tasks`
-  can be submitted. The respective callback is used for every task in the list.
-* `saturated` - A callback that is called when the `queue.length()` hits the concurrency and further tasks will be queued.
-* `empty` - A callback that is called when the last item from the `queue` is given to a `worker`.
-* `drain` - A callback that is called when the last item from the `queue` has returned from the `worker`.
-__Example__
-```js
-// create a cargo object with payload 2
-var cargo = async.cargo(function (tasks, callback) {
-    for(var i=0; i<tasks.length; i++){
-      console.log('hello ' + tasks[i].name);
-    }
-    callback();
-}, 2);
-// add some items
-cargo.push({name: 'foo'}, function (err) {
-    console.log('finished processing foo');
-});
-cargo.push({name: 'bar'}, function (err) {
-    console.log('finished processing bar');
-});
-cargo.push({name: 'baz'}, function (err) {
-    console.log('finished processing baz');
-});
-```
----------------------------------------
-<a name="auto" />
-### auto(tasks, [callback])
-Determines the best order for running the functions in `tasks`, based on their
-requirements. Each function can optionally depend on other functions being completed
-first, and each function is run as soon as its requirements are satisfied.
-If any of the functions pass an error to their callback, it will not
-complete (so any other functions depending on it will not run), and the main
-`callback` is immediately called with the error. Functions also receive an
-object containing the results of functions which have completed so far.
-Note, all functions are called with a `results` object as a second argument,
-so it is unsafe to pass functions in the `tasks` object which cannot handle the
-extra argument.
-For example, this snippet of code:
-```js
-async.auto({
-  readData: async.apply(fs.readFile, 'data.txt', 'utf-8')
-}, callback);
-```
-will have the effect of calling `readFile` with the results object as the last
-argument, which will fail:
-```js
-fs.readFile('data.txt', 'utf-8', cb, {});
-```
-Instead, wrap the call to `readFile` in a function which does not forward the
-`results` object:
-```js
-async.auto({
-  readData: function(cb, results){
-    fs.readFile('data.txt', 'utf-8', cb);
-  }
-}, callback);
-```
-__Arguments__
-* `tasks` - An object. Each of its properties is either a function or an array of
-  requirements, with the function itself the last item in the array. The object's key
-  of a property serves as the name of the task defined by that property,
-  i.e. can be used when specifying requirements for other tasks.
-  The function receives two arguments: (1) a `callback(err, result)` which must be
-  called when finished, passing an `error` (which can be `null`) and the result of
-  the function's execution, and (2) a `results` object, containing the results of
-  the previously executed functions.
-* `callback(err, results)` - An optional callback which is called when all the
-  tasks have been completed. It receives the `err` argument if any `tasks`
-  pass an error to their callback. Results are always returned; however, if
-  an error occurs, no further `tasks` will be performed, and the results
-  object will only contain partial results.
-__Example__
-```js
-async.auto({
-    get_data: function(callback){
-        console.log('in get_data');
-        // async code to get some data
-        callback(null, 'data', 'converted to array');
-    },
-    make_folder: function(callback){
-        console.log('in make_folder');
-        // async code to create a directory to store a file in
-        // this is run at the same time as getting the data
-        callback(null, 'folder');
-    },
-    write_file: ['get_data', 'make_folder', function(callback, results){
-        console.log('in write_file', JSON.stringify(results));
-        // once there is some data and the directory exists,
-        // write the data to a file in the directory
-        callback(null, 'filename');
-    }],
-    email_link: ['write_file', function(callback, results){
-        console.log('in email_link', JSON.stringify(results));
-        // once the file is written let's email a link to it...
-        // results.write_file contains the filename returned by write_file.
-        callback(null, {'file':results.write_file, 'email':'user@example.com'});
-    }]
-}, function(err, results) {
-    console.log('err = ', err);
-    console.log('results = ', results);
-});
-```
-This is a fairly trivial example, but to do this using the basic parallel and
-series functions would look like this:
-```js
-async.parallel([
-    function(callback){
-        console.log('in get_data');
-        // async code to get some data
-        callback(null, 'data', 'converted to array');
-    },
-    function(callback){
-        console.log('in make_folder');
-        // async code to create a directory to store a file in
-        // this is run at the same time as getting the data
-        callback(null, 'folder');
-    }
-],
-function(err, results){
-    async.series([
-        function(callback){
-            console.log('in write_file', JSON.stringify(results));
-            // once there is some data and the directory exists,
-            // write the data to a file in the directory
-            results.push('filename');
-            callback(null);
-        },
-        function(callback){
-            console.log('in email_link', JSON.stringify(results));
-            // once the file is written let's email a link to it...
-            callback(null, {'file':results.pop(), 'email':'user@example.com'});
-        }
-    ]);
-});
-```
-For a complicated series of `async` tasks, using the [`auto`](#auto) function makes adding
-new tasks much easier (and the code more readable).
----------------------------------------
-<a name="retry" />
-### retry([times = 5], task, [callback])
-Attempts to get a successful response from `task` no more than `times` times before
-returning an error. If the task is successful, the `callback` will be passed the result
-of the successfull task. If all attemps fail, the callback will be passed the error and
-result (if any) of the final attempt.
-__Arguments__
-* `times` - An integer indicating how many times to attempt the `task` before giving up. Defaults to 5.
-* `task(callback, results)` - A function which receives two arguments: (1) a `callback(err, result)`
-  which must be called when finished, passing `err` (which can be `null`) and the `result` of
-  the function's execution, and (2) a `results` object, containing the results of
-  the previously executed functions (if nested inside another control flow).
-* `callback(err, results)` - An optional callback which is called when the
-  task has succeeded, or after the final failed attempt. It receives the `err` and `result` arguments of the last attempt at completing the `task`.
-The [`retry`](#retry) function can be used as a stand-alone control flow by passing a
-callback, as shown below:
-```js
-async.retry(3, apiMethod, function(err, result) {
-    // do something with the result
-});
-```
-It can also be embeded within other control flow functions to retry individual methods
-that are not as reliable, like this:
-```js
-async.auto({
-    users: api.getUsers.bind(api),
-    payments: async.retry(3, api.getPayments.bind(api))
-}, function(err, results) {
-  // do something with the results
-});
-```
----------------------------------------
-<a name="iterator" />
-### iterator(tasks)
-Creates an iterator function which calls the next function in the `tasks` array,
-returning a continuation to call the next one after that. It's also possible to
-“peek” at the next iterator with `iterator.next()`.
-This function is used internally by the `async` module, but can be useful when
-you want to manually control the flow of functions in series.
-__Arguments__
-* `tasks` - An array of functions to run.
-__Example__
-```js
-var iterator = async.iterator([
-    function(){ sys.p('one'); },
-    function(){ sys.p('two'); },
-    function(){ sys.p('three'); }
-]);
-node> var iterator2 = iterator();
-'one'
-node> var iterator3 = iterator2();
-'two'
-node> iterator3();
-'three'
-node> var nextfn = iterator2.next();
-node> nextfn();
-'three'
-```
----------------------------------------
-<a name="apply" />
-### apply(function, arguments..)
-Creates a continuation function with some arguments already applied.
-Useful as a shorthand when combined with other control flow functions. Any arguments
-passed to the returned function are added to the arguments originally passed
-to apply.
-__Arguments__
-* `function` - The function you want to eventually apply all arguments to.
-* `arguments...` - Any number of arguments to automatically apply when the
-  continuation is called.
-__Example__
-```js
-// using apply
-async.parallel([
-    async.apply(fs.writeFile, 'testfile1', 'test1'),
-    async.apply(fs.writeFile, 'testfile2', 'test2'),
-]);
-// the same process without using apply
-async.parallel([
-    function(callback){
-        fs.writeFile('testfile1', 'test1', callback);
-    },
-    function(callback){
-        fs.writeFile('testfile2', 'test2', callback);
-    }
-]);
-```
-It's possible to pass any number of additional arguments when calling the
-continuation:
-```js
-node> var fn = async.apply(sys.puts, 'one');
-node> fn('two', 'three');
-one
-two
-three
-```
----------------------------------------
-<a name="nextTick" />
-### nextTick(callback)
-Calls `callback` on a later loop around the event loop. In Node.js this just
-calls `process.nextTick`; in the browser it falls back to `setImmediate(callback)`
-if available, otherwise `setTimeout(callback, 0)`, which means other higher priority
-events may precede the execution of `callback`.
-This is used internally for browser-compatibility purposes.
-__Arguments__
-* `callback` - The function to call on a later loop around the event loop.
-__Example__
-```js
-var call_order = [];
-async.nextTick(function(){
-    call_order.push('two');
-    // call_order now equals ['one','two']
-});
-call_order.push('one')
-```
-<a name="times" />
-### times(n, callback)
-Calls the `callback` function `n` times, and accumulates results in the same manner
-you would use with [`map`](#map).
-__Arguments__
-* `n` - The number of times to run the function.
-* `callback` - The function to call `n` times.
-__Example__
-```js
-// Pretend this is some complicated async factory
-var createUser = function(id, callback) {
-  callback(null, {
-    id: 'user' + id
-  })
-}
-// generate 5 users
-async.times(5, function(n, next){
-    createUser(n, function(err, user) {
-      next(err, user)
-    })
-}, function(err, users) {
-  // we should now have 5 users
-});
-```
-<a name="timesSeries" />
-### timesSeries(n, callback)
-The same as [`times`](#times), only the iterator is applied to each item in `arr` in
-series. The next `iterator` is only called once the current one has completed.
-The results array will be in the same order as the original.
-## Utils
-<a name="memoize" />
-### memoize(fn, [hasher])
-Caches the results of an `async` function. When creating a hash to store function
-results against, the callback is omitted from the hash and an optional hash
-function can be used.
-The cache of results is exposed as the `memo` property of the function returned
-by `memoize`.
-__Arguments__
-* `fn` - The function to proxy and cache results from.
-* `hasher` - Tn optional function for generating a custom hash for storing
-  results. It has all the arguments applied to it apart from the callback, and
-  must be synchronous.
-__Example__
-```js
-var slow_fn = function (name, callback) {
-    // do something
-    callback(null, result);
-};
-var fn = async.memoize(slow_fn);
-// fn can now be used as if it were slow_fn
-fn('some name', function () {
-    // callback
-});
-```
-<a name="unmemoize" />
-### unmemoize(fn)
-Undoes a [`memoize`](#memoize)d function, reverting it to the original, unmemoized
-form. Handy for testing.
-__Arguments__
-* `fn` - the memoized function
-<a name="log" />
-### log(function, arguments)
-Logs the result of an `async` function to the `console`. Only works in Node.js or
-in browsers that support `console.log` and `console.error` (such as FF and Chrome).
-If multiple arguments are returned from the async function, `console.log` is
-called on each argument in order.
-__Arguments__
-* `function` - The function you want to eventually apply all arguments to.
-* `arguments...` - Any number of arguments to apply to the function.
-__Example__
-```js
-var hello = function(name, callback){
-    setTimeout(function(){
-        callback(null, 'hello ' + name);
-    }, 1000);
-};
-```
-```js
-node> async.log(hello, 'world');
-'hello world'
-```
----------------------------------------
-<a name="dir" />
-### dir(function, arguments)
-Logs the result of an `async` function to the `console` using `console.dir` to
-display the properties of the resulting object. Only works in Node.js or
-in browsers that support `console.dir` and `console.error` (such as FF and Chrome).
-If multiple arguments are returned from the async function, `console.dir` is
-called on each argument in order.
-__Arguments__
-* `function` - The function you want to eventually apply all arguments to.
-* `arguments...` - Any number of arguments to apply to the function.
-__Example__
-```js
-var hello = function(name, callback){
-    setTimeout(function(){
-        callback(null, {hello: name});
-    }, 1000);
-};
-```
-```js
-node> async.dir(hello, 'world');
-{hello: 'world'}
-```
----------------------------------------
-<a name="noConflict" />
-### noConflict()
-Changes the value of `async` back to its original value, returning a reference to the
-`async` object.