A simple control-flow library for Node.js targetted towards CoffeeScript developers. It's JavaScript friendly too.
Take a look at the most prominent JavaScript control flow libraries: Async.js, Step, Seq. If you were to use these libraries in CoffeeScript, your code would be an ugly mess.
async = require('async')
async.series(
(->
#first function
),
(->
#second function
)
)
Step = require('step')
Step(
(->
#first function
),
(->
#second function
)
)Seq = require('seq')
Seq().seq(->
#first function
).seq(->
#second function
)Yuck. If you're programming in JavaScript, all of them are very usable solutions. Also, to be fair, they do a lot more than NextFlow. But NextFlow looks much nicer with CoffeeScript programs.
There's been some comments made towards my criticism of async. Justifiably so. When, I wrote NextFlow, I wasn't aware of
async's waterfall and object passing capabilities. However, these methods still have their warts. I still believe that NextFlow is a lightweight library compared to async's do everything approach, I also think that NextFlow's syntax is much more pleasing, even for JavaScript development.
npm install nextflow
next = require('nextflow')
vals = []
x = 0
next flow =
1: ->
vals.push(1)
@next()
2: ->
vals.push(2)
x = Math.random()
@next(x)
3: (num) ->
vals.push(num)
@next()
4: ->
vals.push(4)
@next()
5: ->
console.log vals[0] #is 1
console.log vals[1] #is 2
console.log vals[2] #is x
console.log vals[3] #is 4
vals = []
x = 0
next flow =
a1: ->
vals.push(1)
@a2()
a2: ->
vals.push(2)
x = Math.random()
@a3(x)
a3: (num) ->
vals.push(num)
@a4()
a4: ->
vals.push(4)
@a5()
a5: ->
console.log vals[0] #is 1
console.log vals[1] #is 2
console.log vals[2] #is x
console.log vals[3] #is 4
vals = []
x = 0
y = 0
next flow =
a1: ->
vals.push(1)
@a2()
a2: ->
vals.push(2)
x = Math.random()
@a3(x)
a3: (num) ->
vals.push(num)
y = Math.random()
@next(y)
a4: (num) ->
vals.push(num)
@a5()
a5: ->
console.log vals[0] #is 1
console.log vals[1] #is 2
console.log vals[2] #is x
console.log vals[3] #is y
Handle errors in one function. Label it error:, ERROR: or ErRoR. Case doesn't matter.
next flow =
error: (err) ->
console.log err.message
1: ->
throw new Error('some error')Handle errors by passing them as first params of the @next callback:
next flow =
error: (err) ->
console.log err.message #ENOENT, open '/tmp/this_file_hopefully_does_not_exist'
1: ->
nonExistentFile = '/tmp/this_file_hopefully_does_not_exist'
fs.readFile nonExistentFile, @nextManually call the error function if you want
next flow =
error: (err) ->
console.log err.message #"I feel like calling an error."
a1: ->
@error(new Error("I feel like calling an error."))Example pulled from Rock. Also uses BatchFlow.
next({
ERROR: function(err) {
console.error(err);
},
isRepoPathLocal: function() {
fs.exists(repoPath, this.next);
},
copyIfLocal: function(itsLocal) {
if (itsLocal) {
fs.copy(repoPath, projectPath, this.gitDirExist);
} else {
this.next();
}
},
execGit: function() {
exec(util.format("git clone %s %s", repoPath, projectPath), this.next);
},
gitDirExist: function(params) {
fs.exists(path.join(projectPath, '.git'), this.next);
},
removeGitDir: function(gdirExists) {
if (gdirExists)
fs.remove(path.join(projectPath, '.git'), this.next);
else
this.next();
},
checkRockConf: function() {
fs.exists(projectRockConf, this.next);
},
loadRockConf: function(rockConfExists) {
if (rockConfExists)
fs.readFile(projectRockConf, this.next);
else
this.next();
},
walkFiles: function(err, data) {
var files = [], self = this; ignoreDirs = [];
if (data) {
projectRockObj = JSON.parse(data.toString());
ignoreDirs = projectRockObj.ignoreDirs;
if (ignoreDirs) {
for (var i = 0; i < ignoreDirs.length; ++i) {
ignoreDirs[i] = path.resolve(projectPath, ignoreDirs[i]);
}
} else {
ignoreDirs = [];
}
}
walker(projectPath)
.filterDir(function(dir, stat) {
if (dir === projectRockPath)
return false;
else
if (ignoreDirs.indexOf(dir) >= 0)
return false;
else
return true;
})
.on('file', function(file) { files.push(file) })
.on('end', function() { self.next(files); });
},
tweezeFiles: function(files) {
tweezers.readFilesAndExtractUniq(files, this.next);
},
promptUser: function(err, tokenObj) {
var replacements = {}, self = this;
var rl = readline.createInterface({input: process.stdin, output: process.stdout})
batch(tokenObj.tokens).seq().each(function(i, token, done) {
if (_(getSystemTokens()).keys().indexOf(token) === -1) {
rl.question(token + ': ', function(input){
replacements[token] = input.trim();
done();
});
} else {
replacements[token] = getSystemTokens()[token];
done();
}
}).end(function(){
rl.close();
endCallback();
});
}
});I haven't made this browser compatible just yet, but you can do so with a simple modification of attaching next to the window object. Although, I caution you to test thoroughly, as this module depends upon stability of insertion order into the objects. If this is violated, you're going to have problems. It's my understanding that this is not part of the ECMA standard despite most browsers adhering to this.
Read this discussion for more information: http://code.google.com/p/v8/issues/detail?id=164
MIT Licensed
Copyright (c) 2012 JP Richardson