refactor: move to es6, Maps and Sets

BREAKING CHANGE: moves to es6, works with node 4+

Author: AVVS

.babelrc

@@ -0,0 +1,11 @@
+{
+  "plugins": [
+    "transform-es2015-spread",
+    "transform-es2015-destructuring",
+    "transform-strict-mode",
+    "transform-es2015-parameters",
+    "transform-es2015-shorthand-properties",
+    "transform-object-rest-spread",
+    "transform-class-properties"
+  ]
+}

.editorconfig

@@ -3,7 +3,7 @@ root = true
 
 [*]
 indent_style = space
-indent_size = 4
+indent_size = 2
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true

.eslintrc

@@ -0,0 +1,8 @@
+{
+  "extends": "airbnb/base",
+  "parser": "babel-eslint",
+  "rules": {
+    "no-param-reassign": [2,{"props": false}],
+    "max-len": [2, 150],
+  }
+}

.gitignore

@@ -30,3 +30,4 @@ tags
 .cache
 
 reports
+lib

.jshintrc

@@ -25,3 +25,4 @@ dist
 TAGS
 tags
 .tags
+src

.npmignore

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Vitaly Aminev
+Copyright (c) 2015-2016 Vitaly Aminev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE

@@ -15,36 +15,31 @@ One example would be conserving resources spent on outgoing http requests.
 2. `callbackQueue.remove(String, Error)`: calls queued callbacks with Error argument
 
 ```js
-var callbackQueue = require('callback-queue');
-var request = require('request');
+const callbackQueue = require('callback-queue');
+const request = require('request');
 
 function performOutgoingRequest(url, next) {
-    var callback = callbackQueue.add(url, next);
-    if (!callback) {
-        return;
-    }
+  const callback = callbackQueue.add(url, next);
+  if (!callback) {
+    return;
+  }
 
-    request(url, callback);
+  request(url, callback);
 }
 
-for (var i = 0; i < 100; i++) {
-
-    // request itself will be performed just once
-    performOutgoingRequest('https://google.com', function niceCallback(err, resp, body) {
-        // will be called 100 times
-    });
-
+for (let i = 0; i < 100; i++) {
+  // request itself will be performed just once
+  performOutgoingRequest('https://google.com', function niceCallback(err, resp, body) {
+    // will be called 100 times
+  });
 }
 
-for (var x = 0; x < 100; x++) {
-
-    // request itself will be performed just once
-    performOutgoingRequest('https://google.com', function niceCallback(err, resp, body) {
-        // will be called 100 times with Error object
-    });
-
+for (let x = 0; x < 100; x++) {
+  // request itself will be performed just once
+  performOutgoingRequest('https://google.com', function niceCallback(err, resp, body) {
+      // will be called 100 times with Error object
+  });
 }
 
 callbackQueue.remove('https://google.com', new Error('cancel it!'));
-
 ```

README.md

@@ -1,10 +1,13 @@
 {
   "name": "callback-queue",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "Put your callbacks into queue to make sure that concurrent requests that you might want to perform will only be executed once",
-  "main": "index.js",
+  "main": "./lib/callback-queue.js",
   "scripts": {
-    "test": "multi='spec=- xunit=test-report.xml' ./node_modules/.bin/mocha -R mocha-multi ./test/index.js"
+    "test": "./node_modules/.bin/mocha -r babel-register -R spec test",
+    "prepublish": "npm run compile",
+    "pretest": "npm run compile",
+    "compile": "./node_modules/.bin/babel -d ./lib src"
   },
   "repository": {
     "type": "git",
@@ -22,12 +25,17 @@
   "author": "Vitaly Aminev <[email protected]>",
   "license": "MIT",
   "dependencies": {
-    "debug": "^2.1.3",
-    "lodash.omit": "^3.1.0"
+    "debug": "^2.2.0"
   },
   "devDependencies": {
-    "chai": "^2.2.0",
-    "mocha": "^2.2.1",
-    "mocha-multi": "^0.6.0"
+    "babel-cli": "^6.4.5",
+    "babel-eslint": "^5.0.0",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-preset-stage-0": "^6.3.13",
+    "babel-register": "^6.5.2",
+    "chai": "^3.5.0",
+    "eslint": "^1.10.3",
+    "eslint-config-airbnb": "^5.0.1",
+    "mocha": "^2.4.5"
   }
 }

index.js

@@ -0,0 +1,85 @@
+const debug = require('debug')('callback-queue');
+const assert = require('assert');
+
+/**
+ * Callback queue
+ * @type {Map}
+ */
+const callbackQueue = new Map();
+// cache reference
+const nextTick = typeof setImmediate === 'function' && setImmediate || process.nextTick;
+
+/**
+ * Iterates over callbacks and calls them with passed args
+ * @param {Array} bucket
+ * @param {Array} args
+ */
+function iterateOverCallbacks(bucket, args) {
+  // set iterator
+  for (const thunk of bucket) {
+    nextTick(thunk, ...args);
+  }
+}
+
+/**
+ * Adds callback into queue based on `key` argument
+ * If this is the first callback in the queue, wrapped callback will
+ * be returned, which should be called when any function that you want to perform
+ * will complete. If there are already callbacks in the queue, returns Boolean false,
+ * which indicates that you must not call the function, as it was already called and is
+ * currently in progress
+ *
+ * @param {String}   key      - unique key, based on which requests are bucketed
+ * @param {Function} callback - callback that should be added into requests queue
+ */
+exports.add = function add(key, callback) {
+  assert.equal(typeof key, 'string', 'key must be a truthy string');
+  assert.ok(key, 'key must be a truthy string');
+  assert.equal(typeof callback, 'function', 'callback must be a function');
+
+  const bucket = callbackQueue.get(key);
+  if (bucket) {
+    bucket.add(callback);
+    return false;
+  }
+
+  // push new set into queue
+  callbackQueue.set(key, new Set([callback]));
+
+  return function queuedCallback(...args) {
+    // its essential that we do not use any reference, because of GC
+    // when object reaches certain number of nullified values - its recreated using compactObject
+    // function. Therefore we need to grab a reference when callback needs to be invoked and not at
+    // other time
+    const callbacks = callbackQueue.get(key);
+    if (!callbacks) {
+      debug('Callbacks couldn\'t be invoked');
+      return null;
+    }
+
+    debug('calling callback for key %s', key);
+    callbackQueue.delete(key);
+    return iterateOverCallbacks(callbacks, args);
+  };
+};
+
+/**
+ * Call this if you are absolutely sure you need to abort the request
+ * Every callback in the queue will be called with a passed error object.
+ * Make sure that previously returned callback is not called at a later time,
+ * because if you create a bucket after removing it and then previously returned
+ * callback is executed, it will introduces bugs into your code
+ *
+ * @param  {String} key
+ * @param  {Error}  error
+ */
+exports.remove = function remove(key, error) {
+  const bucket = callbackQueue.get(key);
+  if (!bucket) {
+    return false;
+  }
+
+  assert.ok(error instanceof Error, 'you must pass an instance of Error object when canceling requests');
+  callbackQueue.delete(key);
+  return iterateOverCallbacks(bucket, [error]);
+};