diff options
Diffstat (limited to 'deps/npm/node_modules/request/node_modules/form-data/node_modules/async/README.md')
| -rw-r--r-- | deps/npm/node_modules/request/node_modules/form-data/node_modules/async/README.md | 125 |
1 files changed, 118 insertions, 7 deletions
diff --git a/deps/npm/node_modules/request/node_modules/form-data/node_modules/async/README.md b/deps/npm/node_modules/request/node_modules/form-data/node_modules/async/README.md index 109e045093..f237d59215 100644 --- a/deps/npm/node_modules/request/node_modules/form-data/node_modules/async/README.md +++ b/deps/npm/node_modules/request/node_modules/form-data/node_modules/async/README.md @@ -3,6 +3,8 @@ [](https://travis-ci.org/caolan/async) [](https://www.npmjs.org/package/async) [](https://coveralls.io/r/caolan/async?branch=master) +[](https://gitter.im/caolan/async?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + Async is a utility module which provides straight-forward, powerful functions for working with asynchronous JavaScript. Although originally designed for @@ -190,6 +192,8 @@ Usage: * [`doWhilst`](#doWhilst) * [`until`](#until) * [`doUntil`](#doUntil) +* [`during`](#during) +* [`doDuring`](#doDuring) * [`forever`](#forever) * [`waterfall`](#waterfall) * [`compose`](#compose) @@ -202,17 +206,20 @@ Usage: * [`auto`](#auto) * [`retry`](#retry) * [`iterator`](#iterator) -* [`apply`](#apply) -* [`nextTick`](#nextTick) * [`times`](#times) * [`timesSeries`](#timesSeries) * [`timesLimit`](#timesLimit) ### Utils +* [`apply`](#apply) +* [`nextTick`](#nextTick) * [`memoize`](#memoize) * [`unmemoize`](#unmemoize) * [`ensureAsync`](#ensureAsync) +* [`constant`](#constant) +* [`asyncify`](#asyncify) +* [`wrapSync`](#wrapSync) * [`log`](#log) * [`dir`](#dir) * [`noConflict`](#noConflict) @@ -986,6 +993,42 @@ Like [`doWhilst`](#doWhilst), except the `test` is inverted. Note the argument o --------------------------------------- +<a name="during" /> +### during(test, fn, callback) + +Like [`whilst`](#whilst), except the `test` is an asynchronous function that is passed a callback in the form of `function (err, truth)`. If error is passed to `test` or `fn`, the main callback is immediately called with the value of the error. + +__Example__ + +```js +var count = 0; + +async.during( + function (callback) { + return callback(null, count < 5); + }, + function (callback) { + count++; + setTimeout(callback, 1000); + }, + function (err) { + // 5 seconds have passed + } +); +``` + +--------------------------------------- + +<a name="doDuring" /> +### doDuring(fn, test, callback) + +The post-check version of [`during`](#during). To reflect the difference in +the order of operations, the arguments `test` and `fn` are switched. + +Also a version of [`doWhilst`](#doWhilst) with asynchronous `test` function. + +--------------------------------------- + <a name="forever" /> ### forever(fn, [errback]) @@ -1099,7 +1142,7 @@ Each function is executed with the `this` binding of the composed function. __Arguments__ -* functions... - the asynchronous functions to compose +* `functions...` - the asynchronous functions to compose __Example__ @@ -1459,7 +1502,7 @@ new tasks much easier (and the code more readable). --------------------------------------- <a name="retry" /> -### retry([times = 5], task, [callback]) +### retry([opts = {times: 5, interval: 0}| 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 @@ -1468,7 +1511,8 @@ 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. +* `opts` - Can be either an object with `times` and `interval` or a number. `times` is how many attempts should be made before giving up. `interval` is how long to wait inbetween attempts. Defaults to {times: 5, interval: 0} + * if a number is passed in it sets `times` only (with `interval` defaulting to 0). * `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 @@ -1485,6 +1529,12 @@ async.retry(3, apiMethod, function(err, result) { }); ``` +```js +async.retry({times: 3, interval: 200}, 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: @@ -1646,8 +1696,8 @@ async.times(5, function(n, next){ <a name="timesSeries" /> ### timesSeries(n, iterator, [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 same as [`times`](#times), only the iterator is applied 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="timesLimit" /> @@ -1737,6 +1787,67 @@ async.mapSeries(args, async.ensureAsync(sometimesAsync), done); --------------------------------------- +<a name="constant"> +### constant(values...) + +Returns a function that when called, calls-back with the values provided. Useful as the first function in a `waterfall`, or for plugging values in to `auto`. + +__Example__ + +```js +async.waterfall([ + async.constant(42), + function (value, next) { + // value === 42 + }, + //... +], callback); + +async.waterfall([ + async.constant(filename, "utf8"), + fs.readFile, + function (fileData, next) { + //... + } + //... +], callback); + +async.auto({ + hostname: async.constant("https://server.net/"), + port: findFreePort, + launchServer: ["hostname", "port", function (cb, options) { + startServer(options, cb); + }], + //... +}, callback); + +``` + +--------------------------------------- + +<a name="asyncify"> +<a name="wrapSync"> +### asyncify(func) + +*Alias: wrapSync* + +Take a sync function and make it async, passing its return value to a callback. This is useful for plugging sync functions into a waterfall, series, or other async functions. Any arguments passed to the generated function will be passed to the wrapped function (except for the final callback argument). Errors thrown will be passed to the callback. + +__Example__ + +```js +async.waterfall([ + async.apply(fs.readFile, filename, "utf8"), + async.asyncify(JSON.parse), + function (data, next) { + // data is the result of parsing the text. + // If there was a parsing error, it would have been caught. + } +], callback) +``` + +--------------------------------------- + <a name="log" /> ### log(function, arguments) |