refactor: use es6 arrow functions, const, let

BREAKING CHANGES: `const` and `let` not supported on node < 6

Author: fent

README.md

@@ -11,12 +11,12 @@ A queue with custom concurrency and time limits. Inspired by [caolan/async#queue
 ```js
 const TimeQueue = require('timequeue');
 
-function worker(arg1, arg2, callback) {
+const worker = (arg1, arg2, callback) => {
   someAsyncFunction(calculation(arg1, arg2), callback);
-}
+};
 
 // create a queue with max 5 concurrency every second
-var q = new TimeQueue(worker, { concurrency: 5, every: 1000 });
+let q = new TimeQueue(worker, { concurrency: 5, every: 1000 });
 
 // push tasks onto the queue
 q.push(42, 24);

lib/index.js

@@ -7,8 +7,8 @@ module.exports = class TimeQueue extends EventEmitter {
    * @extends {EventEmitter}
    * @param {Function(..., Function(!Error, ...)} worker
    * @param {Object} options
-   * @param   {Number} concurrency
-   * @param   {Number} time
+   * @param   {number} concurrency
+   * @param   {number} time
    */
   constructor(worker, options) {
     super();
@@ -40,10 +40,10 @@ module.exports = class TimeQueue extends EventEmitter {
   /**
    * Pushes a task onto the queue.
    *
-   * @param {Object} args...
+   * @param {Object} ...args
    * @param {Function(!Error, ...)} callback
    */
-  push() {
+  push(...args) {
     if (this.maxQueued === this.queued) {
       return;
     }
@@ -54,9 +54,9 @@ module.exports = class TimeQueue extends EventEmitter {
       if (this.intransit === this.concurrency) {
         this.emit('full');
       }
-      this._process(arguments);
+      this._process(args);
     } else {
-      this._queue.push(arguments);
+      this._queue.push(args);
       this.queued++;
     }
   }
@@ -65,15 +65,13 @@ module.exports = class TimeQueue extends EventEmitter {
   /**
    * Starts a task
    *
-   * @param {Object} arguments
+   * @param {Array.<Object>} args
    */
   _process(args) {
-    args = Array.prototype.slice.call(args);
-    var callback = args.splice(this.worker.length - 1, 1)[0];
-    var finished = false;
-
-    var every = ~~this.every;
-    var timedOut;
+    const callback = args.splice(this.worker.length - 1, 1)[0];
+    let finished = false;
+    let every = ~~this.every;
+    let timedOut;
 
     if (every) {
       timedOut = false;
@@ -91,26 +89,12 @@ module.exports = class TimeQueue extends EventEmitter {
     }
 
     // If `timeout` option is set, set a timeout to check the task doesn't lag.
-    var taskTimedOut = false;
-    var callbackCalled = false;
-    var timeout = ~~this.timeout;
-
-    if (timeout) {
-      var tid = setTimeout(() => {
-        var err = new Error('Task timed out');
-        err.args = args;
-        taskCallback(err);
-        taskTimedOut = true;
-      }, timeout);
-    }
+    let taskTimedOut = false;
+    let callbackCalled = false;
+    let timeout = ~~this.timeout;
+    let tid;
 
-    // Add missing arguments.
-    while (args.length < this.worker.length - 1) {
-      args.push(undefined);
-    }
-
-    var self = this;
-    function taskCallback(err) {
+    const taskCallback = (err, ...args) => {
       // If this task has timed out, and the callback is called again
       // from the worker, ignore it.
       if (!taskTimedOut) {
@@ -125,32 +109,45 @@ module.exports = class TimeQueue extends EventEmitter {
       }
       callbackCalled = true;
 
-      self.finished++;
-      self.active--;
+      this.finished++;
+      this.active--;
 
       if (typeof callback === 'function') {
         // If a callback was given with the task,
         // call it when the task is finished.
-        callback.apply(null, arguments);
+        callback(err, ...args);
 
       } else if (err) {
         // Otherwise emit an `error` event if there was an error with the task.
-        self.emit('error', err);
+        this.emit('error', err);
       }
 
       finished = true;
       if (timedOut) {
-        self._next();
+        this._next();
       }
+    };
 
+    if (timeout) {
+      tid = setTimeout(() => {
+        const err = new Error('Task timed out');
+        err.args = args;
+        taskCallback(err);
+        taskTimedOut = true;
+      }, timeout);
+    }
+
+    // Add missing arguments.
+    while (args.length < this.worker.length - 1) {
+      args.push(undefined);
     }
 
     // Add custom callback to args.
-    var args2 = args.slice();
+    const args2 = args.slice();
     args2.push(taskCallback);
 
     // Call the worker.
-    this.worker.apply(null, args2);
+    this.worker(...args2);
   }
 
 
@@ -160,10 +157,9 @@ module.exports = class TimeQueue extends EventEmitter {
    */
   _next() {
     if (this.intransit <= this.concurrency && this._queue.length) {
-      var task = this._queue.shift();
       this.queued--;
       this.active++;
-      this._process(task);
+      this._process(this._queue.shift());
 
       if (this._queue.length === 0) {
         this.emit('empty');
@@ -176,7 +172,8 @@ module.exports = class TimeQueue extends EventEmitter {
 
 
   /**
-   * Empties the queue and kills the timers. Active tasks will still be completed.
+   * Empties the queue and kills the timers.
+   * Active tasks will still be completed.
    */
   die() {
     this._queue = [];

package.json

@@ -28,7 +28,7 @@
     "sinon": "^6.0.1"
   },
   "engines": {
-    "node": ">=4"
+    "node": ">=6"
   },
   "license": "MIT"
 }

test/every-test.js

@@ -7,20 +7,20 @@ const concurrency = 3;
 const every = 10;
 const jobs = 10;
 
-var clock;
-before(() => { clock = sinon.useFakeTimers(); });
-after(() => { clock.restore(); });
+let clock;
+before(() => clock = sinon.useFakeTimers());
+after(() => clock.restore());
 
-function runTest(type, worker) {
+const runTest = (type, worker) => {
   describe('Create a queue with a time limit with ' + type, () => {
-    var q = new TimeQueue(worker, { concurrency, every });
+    const q = new TimeQueue(worker, { concurrency, every });
 
     it('Amount of concurrent tasks are not executed over the time limit',
       (done) => {
-        var tid, n = 0, m = 0, timedOut = true;
+        let tid, n = 0, m = 0, timedOut = true;
 
-        function checkJobsFinished() {
-          var diff = q.finished - n;
+        const checkJobsFinished = () => {
+          const diff = q.finished - n;
           assert(diff <= concurrency);
           n = q.finished;
           clearTimeout(tid);
@@ -37,34 +37,34 @@ function runTest(type, worker) {
               clock.tick(every);
             });
           }
-        }
+        };
 
-        function jobFinished() {
+        const jobFinished = () => {
           if (++m === concurrency && timedOut) {
             checkJobsFinished();
             timedOut = false;
           }
-        }
+        };
 
-        for (var i = 0; i < jobs; i++) {
+        for (let i = 0; i < jobs; i++) {
           q.push(i, jobFinished);
         }
       });
   });
-}
+};
 
 runTest('immediate finish', (n, callback) => {
   process.nextTick(callback.bind(null, n));
 });
 
 runTest('finishing time decreasing', (n, callback) => {
-  var ms = n < concurrency ? every + 10 : 0;
+  let ms = n < concurrency ? every + 10 : 0;
   setTimeout(callback.bind(null, n), ms);
   clock.tick(ms);
 });
 
 runTest('random finishing time', (n, callback) => {
-  var ms = Math.floor(Math.random() * every * 2);
+  let ms = Math.floor(Math.random() * every * 2);
   setTimeout(callback.bind(null, n), ms);
   clock.tick(ms);
 });

test/main-test.js

@@ -3,9 +3,8 @@ const assert = require('assert');
 
 
 describe('Create a queue and add to it', () => {
-  var full = false;
-
-  var q = new TimeQueue(process.nextTick.bind(process), { concurrency: 3 });
+  let full = false;
+  const q = new TimeQueue(process.nextTick, { concurrency: 3 });
 
   q.on('full', () => {
     full = true;
@@ -49,7 +48,7 @@ describe('Create a queue and add to it', () => {
   });
 
   describe('With default options', () => {
-    var q = new TimeQueue(process.nextTick.bind(process));
+    const q = new TimeQueue(process.nextTick.bind(process));
     it('Has defaults set', () => {
       assert.equal(q.concurrency, 1);
       assert.equal(q.every, 0);
@@ -60,8 +59,8 @@ describe('Create a queue and add to it', () => {
 
 
 describe('Create a queue with variable number of arguments', () => {
-  var lastA, lastB, lastC;
-  var q = new TimeQueue((a, b, c, callback) => {
+  let lastA, lastB, lastC;
+  const q = new TimeQueue((a, b, c, callback) => {
     lastA = a;
     lastB = b;
     lastC = c;
@@ -120,7 +119,7 @@ describe('Create a queue with variable number of arguments', () => {
 
 
 describe('Create a queue with a worker that always errors', () => {
-  var q = new TimeQueue((callback) => {
+  const q = new TimeQueue((callback) => {
     process.nextTick(() => {
       callback(new Error('gotcha'));
     });
@@ -149,7 +148,7 @@ describe('Create a queue with a worker that always errors', () => {
 
 describe('Create a queue with a callback called twice', () => {
   it('Throws an error', (done) => {
-    var q = new TimeQueue((callback) => {
+    const q = new TimeQueue((callback) => {
       assert.throws(() => {
         callback();
         callback();
@@ -162,8 +161,8 @@ describe('Create a queue with a callback called twice', () => {
 
 
 describe('Create a queue then call its `die` method', () => {
-  var n = 0;
-  var q = new TimeQueue((callback) => {
+  let n = 0;
+  const q = new TimeQueue((callback) => {
     n++;
     process.nextTick(callback);
   }, { concurrency: 3 });

test/maxQueued-test.js

@@ -3,8 +3,8 @@ const assert = require('assert');
 
 
 describe('Create a queue and add to it', () => {
-  var n = 0;
-  var q = new TimeQueue((callback) => {
+  let n = 0;
+  const q = new TimeQueue((callback) => {
     n++;
     process.nextTick(callback);
   }, {
@@ -13,7 +13,7 @@ describe('Create a queue and add to it', () => {
   });
 
   it('Ignores tasks pushed after it is full', (done) => {
-    for (var i = 0; i < 10; i++) {
+    for (let i = 0; i < 10; i++) {
       q.push();
     }
 

test/timeout-test.js

@@ -5,10 +5,10 @@ const sinon = require('sinon');
 
 describe('Create a queue with a timeout', () => {
   describe('With tasks that finish immediately', () => {
-    var q = new TimeQueue(process.nextTick, { timeout: 1000 });
+    const q = new TimeQueue(process.nextTick, { timeout: 1000 });
 
     it('Should execute tasks without problems', (done) => {
-      for (var i = 0; i < 10; i++) {
+      for (let i = 0; i < 10; i++) {
         q.push();
       }
 
@@ -17,12 +17,12 @@ describe('Create a queue with a timeout', () => {
   });
 
   describe('With tasks that lag', () => {
-    var clock;
-    before(() => { clock = sinon.useFakeTimers(); });
-    after(() => { clock.restore(); });
+    let clock;
+    before(() => clock = sinon.useFakeTimers());
+    after(() => clock.restore());
 
     /* jshint unused: false */
-    var q = new TimeQueue((a, b, callback) => {
+    const q = new TimeQueue((a, b, callback) => {
       setTimeout(callback, 100);
     }, { timeout: 50 });