fix(call-limit): Limiter rewrite

Author: iarna

call-limit.js

@@ -1,89 +1,99 @@
 "use strict"
 
-var defaultMaxRunning = 50
+const defaultMaxRunning = 50
 
-var limit = module.exports = function (func, maxRunning) {
-  var running = 0
-  var queue = []
+const limit = module.exports = function (func, maxRunning) {
+  const state = {running: 0, queue: []}
   if (!maxRunning) maxRunning = defaultMaxRunning
   return function limited () {
-    var self = this
-    var args = Array.prototype.slice.call(arguments)
-    if (running >= maxRunning) {
-      queue.push({self: this, args: args})
-      return
+    const args = Array.prototype.slice.call(arguments)
+    if (state.running >= maxRunning) {
+      state.queue.push({obj: this, args})
+    } else {
+      callFunc(this, args)
+    }
+  }
+  function callNext () {
+    if (!state.queue.length) return
+    const next = state.queue.shift()
+    callFunc(next.obj, next.args)
+  }
+  function callFunc (obj, args) {
+    const cb = typeof args[args.length-1] === 'function' && args.pop()
+    try {
+      ++state.running
+      func.apply(obj, args.concat(function () {
+        --state.running
+        process.nextTick(callNext)
+        if (cb) process.nextTick(() => cb.apply(obj, arguments))
+      }))
+    } catch (err) {
+      --state.running
+      if (cb) process.nextTick(() => cb.call(obj, err))
+      process.nextTick(callNext)
     }
-    var cb = typeof args[args.length-1] === 'function' && args.pop()
-    ++ running
-    args.push(function () {
-      var cbargs = arguments
-      -- running
-      cb && process.nextTick(function () {
-        cb.apply(self, cbargs)
-      })
-      if (queue.length) {
-        var next = queue.shift()
-        limited.apply(next.self, next.args)
-      }
-    })
-    func.apply(self, args)
   }
 }
 
 module.exports.method = function (classOrObj, method, maxRunning) {
   if (typeof classOrObj === 'function') {
-    var func = classOrObj.prototype[method]
+    const func = classOrObj.prototype[method]
     classOrObj.prototype[method] = limit(func, maxRunning)
   } else {
-    var func = classOrObj[method]
+    const func = classOrObj[method]
     classOrObj[method] = limit(func, maxRunning)
   }
 }
 
 module.exports.promise = function (func, maxRunning) {
-  var running = 0
-  var queue = []
+  const state = {running: 0, queue: []}
   if (!maxRunning) maxRunning = defaultMaxRunning
-  return function () {
-    var self = this
-    var args = Array.prototype.slice.call(arguments)
-    return new Promise(function (resolve) {
-      if (running >= maxRunning) {
-        queue.push({self: self, args: args, resolve: resolve})
-        return
-      } else {
-        runNext(self, args, resolve)
-      }
-      function runNext (self, args, resolve) {
-        ++ running
-        resolve(
-          func.apply(self, args)
-          .then(function (value) {
-            finish()
-            return value
-          }, function (err) {
-            finish(err)
-            throw err
-          }))
-      }
-
-      function finish () {
-        -- running
-        if (queue.length) {
-          var next = queue.shift()
-          process.nextTick(runNext, next.self, next.args, next.resolve)
-        }
-      }
+  return function limited () {
+    const args = Array.prototype.slice.call(arguments)
+    if (state.running >= maxRunning) {
+      return new Promise(resolve => {
+        state.queue.push({resolve, obj: this, args})
+      })
+    } else {
+      return callFunc(this, args)
+    }
+  }
+  function callNext () {
+    if (!state.queue.length) return
+    const next = state.queue.shift()
+    next.resolve(callFunc(next.obj, next.args))
+  }
+  function callFunc (obj, args) {
+    return callFinally(() => {
+      ++state.running
+      return func.apply(obj, args)
+    }, () => {
+      --state.running
+      process.nextTick(callNext)
     })
   }
+  function callFinally (action, fin) {
+    try {
+      return Promise.resolve(action()).then(value => {
+        fin()
+        return value
+      }, err => {
+        fin()
+        return Promise.reject(err)
+      })
+    } catch (err) {
+      fin()
+      return Promise.reject(err)
+    }
+  }
 }
 
 module.exports.promise.method = function (classOrObj, method, maxRunning) {
   if (typeof classOrObj === 'function') {
-    var func = classOrObj.prototype[method]
+    const func = classOrObj.prototype[method]
     classOrObj.prototype[method] = limit.promise(func, maxRunning)
   } else {
-    var func = classOrObj[method]
+    const func = classOrObj[method]
     classOrObj[method] = limit.promise(func, maxRunning)
   }
 }