runnel
run·nel/ˈrənl/ - A narrow channel in the ground for liquid to flow through.
Simple and small (~ 80 loc) flow control library to execute async functions in sequence.
Table of Contents generated with DocToc
Installation
npm install runnel
Examples
Parameter passing
var runnel = require('runnel');
function uno (cb) {
setTimeout(function () { cb(null, 'eins'); } , 100);
}
function dos (resuno, cb) {
setTimeout(function () { cb(null, resuno, 'zwei'); } , 100);
}
function tres (resuno, resdos, cb) {
setTimeout(function () { cb(null, resuno, resdos, 'drei'); } , 100);
}
runnel(
uno
, dos
, tres
, function done(err, resuno, resdos, restres) {
if (err) return console.error('Error: ', err);
console.log('Success: uno: %s, dos: %s, tres: %s', resuno, resdos, restres);
}
);
Passing Array of functions
var funcs = [uno, dos, tres ];
funcs.push(done);
runnel(funcs);
Seeding a start value
function size (file, acc, cb) {
var p = path.join(__dirname, '..', file);
fs.stat(p, function (err, stat) {
if (err) return cb(err);
acc[file] = stat.size;
cb(null, acc);
});
}
runnel(
runnel.seed({})
, size.bind(null, '.gitignore')
, size.bind(null, '.jshintrc')
, size.bind(null, '.travis.yml')
, function done (err, acc) {
if (err) return console.error(err);
console.log('sizes:', acc);
}
);
full example
same example using array of functions
Features
- intuitive argument passing
- seeding a start value to enable async reduce like functionality
- fails early
- no magic
- no special (ab)uses of
this
- no context passing
- adheres to known nodejs pattern i.e., callbacks are expected to be of the form
function (err[,res]*) { ... }
- super small
- browser support
API
All functions below are expected to invoke the callback like so:
cb(null, res1[, res2][,..]
if no error occurredcb(err)
if an error occurred
runnel(fn1[, fn2][, fn3][, ...], done)
Sequentially runs all the given functions, passing results from one to the next. In case any of the functions calls back
with an error done
will be called with that error immediately.
runnel([fn1, fn2, .., done])
Same as above except that functions are passed as an array rather than as separate values, which allows building up a
flows with array operations like concat
and push
like is done in this example.
More importantly it allows map
ping values to async functions and then execute them sequentially, akin to
Q.all
.
For more information see this real world example.
runnel.seed(value)
Returns a function that will call back with the seeded value
as the result, which can then be consumed by the next
function in line. This allows easily implementing async reduce flows as shown in this
example
Compatibility
- commonJS compatible, so it works with nodejs and browserify
- AMD compliant (i.e., shimlessly works with requirejs)
- attaches itself to the
window
object if neither commonJS or AMD support is detected
Early failure
In order to avoid surprises runnel aborts the entire call chain once any function calls back with an error.
In that case the last function in the chain is called with the error in order to provide feedback that something went wrong.
Why another flow control library
From my experience simple, sequential flow control is sufficient in 90% of the cases and therefore using fuller featured
and therefore also larger flow control libraries is unnecessary in those instances.
runnel however was designed for exactly these situations.
It helps avoid nesting callbacks and results in much more readable and maintainable code.
It also helps minimize repetitive if (err) { cb(err); return; } ...
occurences.
Finally because runnel focuses only on one thing it's a very small module (~ 80 loc).
More Examples
Looky here: examples or consult the tests.
Similar libraries with larger feature set