diff options
Diffstat (limited to 'node_modules/a-sync-waterfall')
| -rw-r--r-- | node_modules/a-sync-waterfall/LICENSE | 21 | ||||
| -rw-r--r-- | node_modules/a-sync-waterfall/README.md | 95 | ||||
| -rw-r--r-- | node_modules/a-sync-waterfall/index.js | 83 | ||||
| -rw-r--r-- | node_modules/a-sync-waterfall/package.json | 21 | ||||
| -rw-r--r-- | node_modules/a-sync-waterfall/test.js | 77 |
5 files changed, 297 insertions, 0 deletions
diff --git a/node_modules/a-sync-waterfall/LICENSE b/node_modules/a-sync-waterfall/LICENSE new file mode 100644 index 0000000..e684cdb --- /dev/null +++ b/node_modules/a-sync-waterfall/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2013 Elan Shanker + +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. diff --git a/node_modules/a-sync-waterfall/README.md b/node_modules/a-sync-waterfall/README.md new file mode 100644 index 0000000..e3d5afe --- /dev/null +++ b/node_modules/a-sync-waterfall/README.md @@ -0,0 +1,95 @@ +# a-sync-waterfall + +Simple, isolated sync/async waterfall module for JavaScript. + +Runs an array of functions in series, each passing their results to the next in +the array. However, if any of the functions pass an error to the callback, the +next function is not executed and the main callback is immediately called with +the error. + +For browsers and node.js. + +## Installation +* Just include a-sync-waterfall before your scripts. +* `npm install a-sync-waterfall` if you’re using node.js. + + +## Usage + +* `waterfall(tasks, optionalCallback, forceAsync);` +* **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. +* **optionalCallback** - An optional callback to run once all the functions have +completed. This will be passed the results of the last task's callback. +* **forceAsync** An optional flag that force tasks run asynchronously even if they are sync. + +##### Node.js: + +```javascript +var waterfall = require('a-sync-waterfall'); +waterfall(tasks, callback); +``` + +##### Browser: + +```javascript +var waterfall = require('a-sync-waterfall'); +waterfall(tasks, callback); + +// Default: +window.waterfall(tasks, callback); +``` + +##### Tasks as Array of Functions + +```javascript +waterfall([ + function(callback){ + callback(null, 'one', 'two'); + }, + function(arg1, arg2, callback){ + callback(null, 'three'); + }, + function(arg1, callback){ + // arg1 now equals 'three' + callback(null, 'done'); + } +], function (err, result) { + // result now equals 'done' +}); +``` + +##### Derive Tasks from an Array.map + +```javascript +/* basic - no arguments */ +waterfall(myArray.map(function (arrayItem) { + return function (nextCallback) { + // same execution for each item, call the next one when done + doAsyncThingsWith(arrayItem, nextCallback); +}})); + +/* with arguments, initializer function, and final callback */ +waterfall([function initializer (firstMapFunction) { + firstMapFunction(null, initialValue); + }].concat(myArray.map(function (arrayItem) { + return function (lastItemResult, nextCallback) { + // same execution for each item in the array + var itemResult = doThingsWith(arrayItem, lastItemResult); + // results carried along from each to the next + nextCallback(null, itemResult); +}})), function (err, finalResult) { + // final callback +}); +``` + +## Acknowledgements +Hat tip to [Caolan McMahon](https://github.com/caolan) and +[Paul Miller](https://github.com/paulmillr), whose prior contributions this is +based upon. +Also [Elan Shanker](https://github.com/es128) from which this rep is forked + +## License +[MIT](https://raw.github.com/hydiak/a-sync-waterfall/master/LICENSE) diff --git a/node_modules/a-sync-waterfall/index.js b/node_modules/a-sync-waterfall/index.js new file mode 100644 index 0000000..5671213 --- /dev/null +++ b/node_modules/a-sync-waterfall/index.js @@ -0,0 +1,83 @@ +// MIT license (by Elan Shanker). +(function(globals) { + 'use strict'; + + var executeSync = function(){ + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'function'){ + args[0].apply(null, args.splice(1)); + } + }; + + var executeAsync = function(fn){ + if (typeof setImmediate === 'function') { + setImmediate(fn); + } else if (typeof process !== 'undefined' && process.nextTick) { + process.nextTick(fn); + } else { + setTimeout(fn, 0); + } + }; + + var makeIterator = function (tasks) { + var makeCallback = function (index) { + var fn = function () { + if (tasks.length) { + tasks[index].apply(null, arguments); + } + return fn.next(); + }; + fn.next = function () { + return (index < tasks.length - 1) ? makeCallback(index + 1): null; + }; + return fn; + }; + return makeCallback(0); + }; + + var _isArray = Array.isArray || function(maybeArray){ + return Object.prototype.toString.call(maybeArray) === '[object Array]'; + }; + + var waterfall = function (tasks, callback, forceAsync) { + var nextTick = forceAsync ? executeAsync : executeSync; + callback = callback || function () {}; + if (!_isArray(tasks)) { + var err = new Error('First argument to waterfall must be an array of functions'); + return callback(err); + } + if (!tasks.length) { + return callback(); + } + var wrapIterator = function (iterator) { + return function (err) { + if (err) { + callback.apply(null, arguments); + callback = function () {}; + } else { + var args = Array.prototype.slice.call(arguments, 1); + var next = iterator.next(); + if (next) { + args.push(wrapIterator(next)); + } else { + args.push(callback); + } + nextTick(function () { + iterator.apply(null, args); + }); + } + }; + }; + wrapIterator(makeIterator(tasks))(); + }; + + if (typeof define !== 'undefined' && define.amd) { + define([], function () { + return waterfall; + }); // RequireJS + } else if (typeof module !== 'undefined' && module.exports) { + module.exports = waterfall; // CommonJS + } else { + globals.waterfall = waterfall; // <script> + } +})(this); diff --git a/node_modules/a-sync-waterfall/package.json b/node_modules/a-sync-waterfall/package.json new file mode 100644 index 0000000..39219c8 --- /dev/null +++ b/node_modules/a-sync-waterfall/package.json @@ -0,0 +1,21 @@ +{ + "name": "a-sync-waterfall", + "version": "1.0.1", + "description": "Runs a list of async tasks, passing the results of each into the next one", + "author": { + "name": "Gleb Khudyakov", + "url": "https://github.com/hydiak/a-sync-waterfall" + }, + "license": "MIT", + "homepage": "https://github.com/hydiak/a-sync-waterfall", + "repository": { + "type": "git", + "url": "git@github.com:hydiak/a-sync-waterfall.git" + }, + "bugs": { + "url": "https://github.com/hydiak/a-sync-waterfall/issues" + }, + "main": "./index", + "keywords": ["async", "sync", "waterfall", "tasks", "control", "flow"], + "dependencies": {} +} diff --git a/node_modules/a-sync-waterfall/test.js b/node_modules/a-sync-waterfall/test.js new file mode 100644 index 0000000..ebb5883 --- /dev/null +++ b/node_modules/a-sync-waterfall/test.js @@ -0,0 +1,77 @@ +"use strict"; +const waterfall = require('./index'); + +var generateSyncTask = function(index) { + return function (x){ + return function(cb){ + console.log(x); + cb(null); + }; + }(index); +}; + + +var generateAsyncTask = function(index) { + return function (x){ + return function(cb){ + setTimeout(function(){ + console.log(x); + cb(null); + }, 0); + }; + }(index); +}; + +var generateSyncTasks = function(count){ + var tasks = []; + for(var i=0; i<count; i++) { + tasks.push(generateSyncTask(i)); + } + return tasks; +} + +var generateAsyncTasks = function(count){ + var tasks = []; + for(var i=0; i<count; i++) { + tasks.push(generateAsyncTask(i)); + } + return tasks; +} + + +var generateRandomTasks = function(count){ + var tasks = []; + for(var i=0; i<count; i++) { + Math.random() > .5 ? tasks.push(generateAsyncTask(i)) : tasks.push(generateSyncTask(i)) + } + return tasks; +} + +var done = function(){ + console.log('done'); +} + +var testSync = function(){ + waterfall(generateSyncTasks(10), done); + console.log('this text should be after waterfall'); + +}; + +var testAsync = function(){ + waterfall(generateAsyncTasks(5), done); + console.log('this text should be before waterfall'); +}; + +var testMixed = function(){ + waterfall(generateRandomTasks(20), done); +}; + + +console.log('testSync:'); +testSync(); + +// console.log('\ntestAsync: '); +// testAsync(); + +console.log('\ntestMixed: '); +testMixed();
\ No newline at end of file |