kareem 2.0.6 → 2.2.1

package/index.js

@@ -1,8 +1,8 @@
 'use strict';
 
 function Kareem() {
-  this._pres = {};
-  this._posts = {};
+  this._pres = new Map();
+  this._posts = new Map();
 }
 
 Kareem.prototype.execPre = function(name, context, args, callback) {
@@ -218,10 +218,10 @@ Kareem.prototype.execPost = function(name, context, args, options, callback) {
 };
 
 Kareem.prototype.execPostSync = function(name, context, args) {
-  var posts = get(this._posts, name, []);
-  var numPosts = posts.length;
+  const posts = get(this._posts, name, []);
+  const numPosts = posts.length;
 
-  for (var i = 0; i < numPosts; ++i) {
+  for (let i = 0; i < numPosts; ++i) {
     posts[i].apply(context, args || []);
   }
 };
@@ -253,18 +253,19 @@ function _handleWrapError(instance, error, name, context, args, options, callbac
 }
 
 Kareem.prototype.wrap = function(name, fn, context, args, options) {
-  var lastArg = (args.length > 0 ? args[args.length - 1] : null);
-  var argsWithoutCb = typeof lastArg === 'function' ?
+  const lastArg = (args.length > 0 ? args[args.length - 1] : null);
+  const argsWithoutCb = typeof lastArg === 'function' ?
     args.slice(0, args.length - 1) :
     args;
-  var _this = this;
+  const _this = this;
 
   options = options || {};
+  const checkForPromise = options.checkForPromise;
 
   this.execPre(name, context, args, function(error) {
     if (error) {
-      var numCallbackParams = options.numCallbackParams || 0;
-      var errorArgs = options.contextParameter ? [context] : [];
+      const numCallbackParams = options.numCallbackParams || 0;
+      const errorArgs = options.contextParameter ? [context] : [];
       for (var i = errorArgs.length; i < numCallbackParams; ++i) {
         errorArgs.push(null);
       }
@@ -272,12 +273,29 @@ Kareem.prototype.wrap = function(name, fn, context, args, options) {
         options, lastArg);
     }
 
-    var end = (typeof lastArg === 'function' ? args.length - 1 : args.length);
-    fn.apply(context, args.slice(0, end).concat(_cb));
+    const end = (typeof lastArg === 'function' ? args.length - 1 : args.length);
+    const numParameters = fn.length;
+    const ret = fn.apply(context, args.slice(0, end).concat(_cb));
+
+    if (checkForPromise) {
+      if (ret != null && typeof ret.then === 'function') {
+        // Thenable, use it
+        return ret.then(
+          res => _cb(null, res),
+          err => _cb(err)
+        );
+      }
+
+      // If `fn()` doesn't have a callback argument and doesn't return a
+      // promise, assume it is sync
+      if (numParameters < end + 1) {
+        return _cb(null, ret);
+      }
+    }
 
     function _cb() {
-      var args = arguments;
-      var argsWithoutError = Array.prototype.slice.call(arguments, 1);
+      const args = arguments;
+      const argsWithoutError = Array.prototype.slice.call(arguments, 1);
       if (options.nullResultByDefault && argsWithoutError.length === 0) {
         argsWithoutError.push(null);
       }
@@ -302,9 +320,13 @@ Kareem.prototype.wrap = function(name, fn, context, args, options) {
   });
 };
 
+Kareem.prototype.hasHooks = function(name) {
+  return this._pres.has(name) || this._posts.has(name);
+};
+
 Kareem.prototype.createWrapper = function(name, fn, context, options) {
   var _this = this;
-  if (this._pres[name] == null && this._posts[name] == null) {
+  if (!this.hasHooks(name)) {
     // Fast path: if there's no hooks for this function, just return the
     // function wrapped in a nextTick()
     return function() {
@@ -325,8 +347,8 @@ Kareem.prototype.pre = function(name, isAsync, fn, error, unshift) {
     isAsync = false;
   }
 
-  this._pres[name] = get(this._pres, name, []);
-  const pres = this._pres[name];
+  const pres = get(this._pres, name, []);
+  this._pres.set(name, pres);
 
   if (isAsync) {
     pres.numAsync = pres.numAsync || 0;
@@ -343,25 +365,27 @@ Kareem.prototype.pre = function(name, isAsync, fn, error, unshift) {
 };
 
 Kareem.prototype.post = function(name, fn, unshift) {
-  this._posts[name] = get(this._posts, name, []);
+  const hooks = get(this._posts, name, []);
 
   if (unshift) {
-    this._posts[name].unshift(fn);
+    hooks.unshift(fn);
   } else {
-    this._posts[name].push(fn);
+    hooks.push(fn);
   }
+  this._posts.set(name, hooks);
   return this;
 };
 
 Kareem.prototype.clone = function() {
   const n = new Kareem();
 
-  for (let key of Object.keys(this._pres)) {
-    n._pres[key] = this._pres[key].slice();
-    n._pres[key].numAsync = this._pres[key].numAsync;
+  for (let key of this._pres.keys()) {
+    const clone = this._pres.get(key).slice();
+    clone.numAsync = this._pres.get(key).numAsync;
+    n._pres.set(key, clone);
   }
-  for (let key of Object.keys(this._posts)) {
-    n._posts[key] = this._posts[key].slice();
+  for (let key of this._posts.keys()) {
+    n._posts.set(key, this._posts.get(key).slice());
   }
 
   return n;
@@ -370,28 +394,29 @@ Kareem.prototype.clone = function() {
 Kareem.prototype.merge = function(other) {
   var ret = this.clone();
 
-  for (let key of Object.keys(other._pres)) {
+  for (let key of other._pres.keys()) {
     const sourcePres = get(ret._pres, key, []);
-    const deduplicated = other._pres[key].
+    const deduplicated = other._pres.get(key).
       // Deduplicate based on `fn`
       filter(p => sourcePres.map(_p => _p.fn).indexOf(p.fn) === -1);
-    ret._pres[key] = sourcePres.concat(deduplicated);
-    ret._pres[key].numAsync = get(ret._pres[key], 'numAsync', 0);
-    ret._pres[key].numAsync += deduplicated.filter(p => p.isAsync).length;
+    const combined = sourcePres.concat(deduplicated);
+    combined.numAsync = sourcePres.numAsync || 0;
+    combined.numAsync += deduplicated.filter(p => p.isAsync).length;
+    ret._pres.set(key, combined);
   }
-  for (let key of Object.keys(other._posts)) {
+  for (let key of other._posts.keys()) {
     const sourcePosts = get(ret._posts, key, []);
-    const deduplicated = other._posts[key].
+    const deduplicated = other._posts.get(key).
       filter(p => sourcePosts.indexOf(p) === -1);
-    ret._posts[key] = sourcePosts.concat(deduplicated);
+    ret._posts.set(key, sourcePosts.concat(deduplicated));
   }
 
   return ret;
 };
 
-function get(obj, key, def) {
-  if (obj[key] != null) {
-    return obj[key];
+function get(map, key, def) {
+  if (map.has(key)) {
+    return map.get(key);
   }
   return def;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kareem",
-  "version": "2.0.6",
+  "version": "2.2.1",
   "description": "Next-generation take on pre/post function hooks",
   "main": "index.js",
   "scripts": {

package/test/examples.test.js

@@ -355,8 +355,8 @@ describe('clone()', function() {
     k1.post('cook', function() {});
 
     var k2 = k1.clone();
-    assert.deepEqual(['cook'], Object.keys(k2._pres));
-    assert.deepEqual(['cook'], Object.keys(k2._posts));
+    assert.deepEqual(Array.from(k2._pres.keys()), ['cook']);
+    assert.deepEqual(Array.from(k2._posts.keys()), ['cook']);
   });
 });
 
@@ -371,9 +371,9 @@ describe('merge()', function() {
     var test2 = function() {};
     k2.pre('cook', test2);
     var k3 = k2.merge(k1);
-    assert.equal(k3._pres['cook'].length, 2);
-    assert.equal(k3._pres['cook'][0].fn, test2);
-    assert.equal(k3._pres['cook'][1].fn, test1);
-    assert.equal(k3._posts['cook'].length, 1);
+    assert.equal(k3._pres.get('cook').length, 2);
+    assert.equal(k3._pres.get('cook')[0].fn, test2);
+    assert.equal(k3._pres.get('cook')[1].fn, test1);
+    assert.equal(k3._posts.get('cook').length, 1);
   });
 });

package/test/misc.test.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require('assert');
+const Kareem = require('../');
+
+describe('hasHooks', function() {
+  it('returns false for toString (Automattic/mongoose#6538)', function() {
+    const k = new Kareem();
+    assert.ok(!k.hasHooks('toString'));
+  });
+});
+
+describe('merge', function() {
+  it('handles async pres if source doesnt have them', function() {
+    const k1 = new Kareem();
+    k1.pre('cook', true, function(next, done) {
+      execed.first = true;
+      setTimeout(
+        function() {
+          done('error!');
+        },
+        5);
+
+      next();
+    });
+
+    assert.equal(k1._pres.get('cook').numAsync, 1);
+
+    const k2 = new Kareem();
+    const k3 = k2.merge(k1);
+    assert.equal(k3._pres.get('cook').numAsync, 1);
+  });
+});

package/test/post.test.js

@@ -1,5 +1,7 @@
-var assert = require('assert');
-var Kareem = require('../');
+'use strict';
+
+const assert = require('assert');
+const Kareem = require('../');
 
 describe('execPost', function() {
   var hooks;
@@ -25,8 +27,8 @@ describe('execPost', function() {
     var f2 = function() {};
     hooks.post('cook', f1);
     hooks.post('cook', f2, true);
-    assert.strictEqual(hooks._posts['cook'][0], f2);
-    assert.strictEqual(hooks._posts['cook'][1], f1);
+    assert.strictEqual(hooks._posts.get('cook')[0], f2);
+    assert.strictEqual(hooks._posts.get('cook')[1], f1);
   });
 
   it('multiple posts', function(done) {

package/test/pre.test.js

@@ -1,5 +1,7 @@
-var assert = require('assert');
-var Kareem = require('../');
+'use strict';
+
+const assert = require('assert');
+const Kareem = require('../');
 
 describe('execPre', function() {
   var hooks;
@@ -59,8 +61,8 @@ describe('execPre', function() {
     var f2 = function() {};
     hooks.pre('cook', false, f1);
     hooks.pre('cook', false, f2, null, true);
-    assert.strictEqual(hooks._pres['cook'][0].fn, f2);
-    assert.strictEqual(hooks._pres['cook'][1].fn, f1);
+    assert.strictEqual(hooks._pres.get('cook')[0].fn, f2);
+    assert.strictEqual(hooks._pres.get('cook')[1].fn, f1);
   });
 
   it('handles async errors', function(done) {