Support custom runner

Author: zoubin

README.md

@@ -242,5 +242,19 @@ Type: `Boolean`
 
 Default: `true`
 
+##### run
+Specify a runner function to run each callback.
+
+Type: `Function`, `Object`
+
+Default: `null`
+
+If `Function`, it receives a callback followed by a list of arguments,
+and should return a promise to fetch the results (`Array`).
+
+If `Object`, it is passed to
+[`Runner of run-callback`](https://github.com/zoubin/run-callback#runner--runrunner)
+to create a runner function.
+
 ## [Changelog](changelog.md)
 

lib/runner.js

@@ -9,28 +9,48 @@ function Runner(opts) {
   opts = opts || {}
   this.input = opts.input !== false
   this.output = opts.output !== false
+  if (typeof opts.run === 'function') {
+    this._run = opts.run
+  } else {
+    this._runner = runCallback.Runner(opts.run)
+  }
 }
 
 Runner.prototype.normalizeArgs = function(args) {
-  return this.input && defined(args) ? args : []
+  if (!this.input || !defined(args)) return []
+  return Array.isArray(args) ? args : [args]
+}
+
+Runner.prototype.normalizeResult = function(res) {
+  return this.output ? res : []
 }
 
 Runner.prototype.run = function(cb, args) {
-  args = this.normalizeArgs(args)
-  return runCallback.apply(null, [cb].concat(args))
+  args = [cb].concat(args)
+  return Promise.resolve(this).then(function (runner) {
+    return runner._run.apply(runner, args)
+  })
+}
+
+Runner.prototype._run = function(cb) {
+  return this._runner.thunkify(cb)
+    .apply(this._runner, slice(arguments, 1))
 }
 
 Runner.prototype.sequence = function(cbs, args, i) {
-  i = ~~i
+  if (!Array.isArray(cbs)) cbs = [cbs]
+  args = this.normalizeArgs(args)
 
-  // NOTE: tasks can be pushed to `cbs` dynamically
+  i = ~~i
   var cb = cbs[i]
+
+  // **NOTE**: tasks can be pushed to `cbs` dynamically
+  if (i < cbs.length) ++i
+
   var ret
   if (typeof cb === 'function') {
-    ++i
     ret = this.run(cb, args)
   } else if (Array.isArray(cb)) {
-    ++i
     ret = this.parallel(cb, args)
   } else {
     ret = Promise.resolve(args)
@@ -41,12 +61,14 @@ Runner.prototype.sequence = function(cbs, args, i) {
     if (i < cbs.length) {
       return self.sequence(cbs, res, i)
     }
-    if (self.output) return res
+    return self.normalizeResult(res)
   })
 }
 
 Runner.prototype.parallel = function(cbs, args) {
-  var self = this
+  if (!Array.isArray(cbs)) cbs = [cbs]
+  args = this.normalizeArgs(args)
+
   return Promise.all(cbs.map(function (cb) {
     if (typeof cb === 'function') {
       return this.run(cb, args)
@@ -56,9 +78,7 @@ Runner.prototype.parallel = function(cbs, args) {
     }
     return Promise.resolve(args)
   }, this))
-  .then(function (res) {
-    if (self.output) return res
-  })
+  .then(this.normalizeResult.bind(this))
 }
 
 Runner.prototype.thunkify = function() {

package.json

@@ -26,7 +26,7 @@
   },
   "homepage": "https://github.com/zoubin/callback-sequence#readme",
   "dependencies": {
-    "run-callback": "^3.0.0"
+    "run-callback": "^3.1.0"
   },
   "devDependencies": {
     "eslint": "^1.10.1",

test/custom-runner.js

@@ -0,0 +1,46 @@
+var test = require('tap').test
+var Runner = require('..').Runner
+
+test('custom run function', function(t) {
+  var ctx = {}
+  var runner = Runner({
+    run: function (cb) {
+      return [cb.apply(ctx, Array.prototype.slice.call(arguments, 1))]
+    },
+  })
+
+  return runner.sequence([
+    function () {
+      t.equal(this, ctx)
+      return 1
+    },
+    function (a) {
+      t.equal(a, 1)
+      t.equal(this, ctx)
+      return 2
+    },
+  ]).then(function (res) {
+    t.same(res, [2])
+  })
+})
+
+test('custom runner option', function(t) {
+  var runner = Runner({
+    run: { async: false },
+  })
+
+  return runner.sequence([
+    function () {
+      t.equal(arguments.length, 0)
+      return 1
+    },
+    function (a) {
+      t.equal(a, 1)
+      t.equal(arguments.length, 1)
+      return Promise.resolve(2)
+    },
+  ]).then(function (res) {
+    t.same(res, [2])
+  })
+})
+

test/input.js

@@ -84,3 +84,19 @@ test('disabled', function(t) {
   ], [1, 2])
 })
 
+test('single function', function(tt) {
+  tt.test('sequence', function(t) {
+    return run(function (next) {
+      t.equal(arguments.length, 1)
+      next()
+    })
+  })
+  tt.test('parallel', function(t) {
+    return parallel(function (next) {
+      t.equal(arguments.length, 1)
+      next()
+    })
+  })
+  tt.end()
+})
+

test/output.js

@@ -140,15 +140,35 @@ test('thunkify', function(t) {
   })
 })
 
-test('disabled', function(t) {
+test('disabled', function(tt) {
   var scheduler = Runner({ output: false })
-  return scheduler.sequence([
-    function (next) {
-      next(null, 1, 2)
-    },
-  ])
-  .then(function (res) {
-    t.equal(typeof res, 'undefined')
+  tt.test('sequence', function(t) {
+    return scheduler.sequence([
+      function (next) {
+        next(null, 1)
+      },
+      function (a, next) {
+        t.equal(a, 1)
+        next(null, 1, 2)
+      },
+    ])
+    .then(function (res) {
+      t.same(res, [])
+    })
+  })
+  tt.test('parallel', function(t) {
+    return scheduler.parallel([
+      function (next) {
+        next(null, 1)
+      },
+      function (next) {
+        next(null, 1, 2)
+      },
+    ])
+    .then(function (res) {
+      t.same(res, [])
+    })
   })
+  tt.end()
 })