Add util.promisify

Author: goto-bus-stop

test/node/index.js

@@ -15,5 +15,6 @@ series([
   test(require.resolve('./debug')),
   test(require.resolve('./format')),
   test(require.resolve('./inspect')),
-  test(require.resolve('./log'))
+  test(require.resolve('./log')),
+  test(require.resolve('./promisify'))
 ]);

test/node/promisify.js

@@ -0,0 +1,228 @@
+var assert = require('assert');
+var fs = require('fs');
+var vm = require('vm');
+var promisify = require('../../util').promisify;
+
+if (typeof Promise === 'undefined') {
+  console.log('no global Promise found, skipping promisify tests');
+  return;
+}
+
+var mustCalls = [];
+var common = {
+  expectsError: function (fn, props) {
+    try { fn(); }
+    catch (err) {
+      if (props.type) assert.equal(err.constructor, props.type);
+      if (props.message) assert.equal(err.message, props.message);
+      return;
+    }
+    assert.fail('expected error');
+  },
+  mustCall: function (fn) {
+    function mustCall() {
+      mustCall.called = true
+      return fn.apply(this, arguments);
+    }
+
+    mustCalls.push(mustCall);
+    return mustCall;
+  }
+};
+
+var stat = promisify(fs.stat);
+
+{
+  var promise = stat(__filename);
+  assert(promise instanceof Promise);
+  promise.then(common.mustCall(function (value) {
+    assert.deepStrictEqual(value, fs.statSync(__filename));
+  }));
+}
+
+{
+  var promise = stat('/dontexist');
+  promise.catch(common.mustCall(function (error) {
+    assert(error.message.indexOf('ENOENT: no such file or directory, stat') !== -1);
+  }));
+}
+
+{
+  function fn() {}
+  function promisifedFn() {}
+  fn[promisify.custom] = promisifedFn;
+  assert.strictEqual(promisify(fn), promisifedFn);
+  assert.strictEqual(promisify(promisify(fn)), promisifedFn);
+}
+
+{
+  function fn2() {}
+  fn2[promisify.custom] = 42;
+  common.expectsError(
+    function () { promisify(fn2); },
+    { code: 'ERR_INVALID_ARG_TYPE', type: TypeError }
+  );
+}
+
+// promisify args test disabled, it is an internal core API that is
+// not used anywhere anymore and this package does not implement it.
+if (false) {
+  var firstValue = 5;
+  var secondValue = 17;
+
+  function fn3(callback) {
+    callback(null, firstValue, secondValue);
+  }
+
+  fn3[customPromisifyArgs] = ['first', 'second'];
+
+  promisify(fn3)().then(common.mustCall(function (obj) {
+    assert.deepStrictEqual(obj, { first: firstValue, second: secondValue });
+  }));
+}
+
+{
+  var fn4 = vm.runInNewContext('(function() {})');
+  assert.notStrictEqual(Object.getPrototypeOf(promisify(fn4)),
+                        Function.prototype);
+}
+
+{
+  function fn5(callback) {
+    callback(null, 'foo', 'bar');
+  }
+  promisify(fn5)().then(common.mustCall(function (value) {
+    assert.deepStrictEqual(value, 'foo');
+  }));
+}
+
+{
+  function fn6(callback) {
+    callback(null);
+  }
+  promisify(fn6)().then(common.mustCall(function (value) {
+    assert.strictEqual(value, undefined);
+  }));
+}
+
+{
+  function fn7(callback) {
+    callback();
+  }
+  promisify(fn7)().then(common.mustCall(function (value) {
+    assert.strictEqual(value, undefined);
+  }));
+}
+
+{
+  function fn8(err, val, callback) {
+    callback(err, val);
+  }
+  promisify(fn8)(null, 42).then(common.mustCall(function (value) {
+    assert.strictEqual(value, 42);
+  }));
+}
+
+{
+  function fn9(err, val, callback) {
+    callback(err, val);
+  }
+  promisify(fn9)(new Error('oops'), null).catch(common.mustCall(function (err) {
+    assert.strictEqual(err.message, 'oops');
+  }));
+}
+
+{
+  function fn9(err, val, callback) {
+    callback(err, val);
+  }
+
+
+  Promise.resolve()
+    .then(function () { return promisify(fn9)(null, 42); })
+    .then(function (value) {
+      assert.strictEqual(value, 42);
+    });
+}
+
+{
+  var o = {};
+  var fn10 = promisify(function(cb) {
+
+    cb(null, this === o);
+  });
+
+  o.fn = fn10;
+
+  o.fn().then(common.mustCall(function(val) {
+    assert(val);
+  }));
+}
+
+(function () {
+  var err = new Error('Should not have called the callback with the error.');
+  var stack = err.stack;
+
+  var fn11 = promisify(function(cb) {
+    cb(null);
+    cb(err);
+  });
+
+  Promise.resolve()
+    .then(function () { return fn11(); })
+    .then(function () { return Promise.resolve(); })
+    .then(function () {
+      assert.strictEqual(stack, err.stack);
+    });
+})();
+
+{
+  function c() { }
+  var a = promisify(function() { });
+  var b = promisify(a);
+  assert.notStrictEqual(c, a);
+  assert.strictEqual(a, b);
+}
+
+{
+  var errToThrow;
+  var thrower = promisify(function(a, b, c, cb) {
+    errToThrow = new Error();
+    throw errToThrow;
+  });
+  thrower(1, 2, 3)
+    .then(assert.fail)
+    .then(assert.fail, function (e) { assert.strictEqual(e, errToThrow); });
+}
+
+{
+  var err = new Error();
+
+  var a = promisify(function (cb) { cb(err) })();
+  var b = promisify(function () { throw err; })();
+
+  Promise.all([
+    a.then(assert.fail, function(e) {
+      assert.strictEqual(err, e);
+    }),
+    b.then(assert.fail, function(e) {
+      assert.strictEqual(err, e);
+    })
+  ]);
+}
+
+[undefined, null, true, 0, 'str', {}, [], Symbol()].forEach(function (input) {
+  common.expectsError(
+    function () { promisify(input); },
+    {
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "original" argument must be of type Function'
+    });
+});
+
+process.on('exit', function () {
+  mustCalls.forEach(function (mc) {
+    assert(mc.called);
+  });
+});

util.js

@@ -584,3 +584,61 @@ exports._extend = function(origin, add) {
 function hasOwnProperty(obj, prop) {
   return Object.prototype.hasOwnProperty.call(obj, prop);
 }
+
+var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
+
+exports.promisify = function promisify(original) {
+  if (typeof original !== 'function')
+    throw new TypeError('The "original" argument must be of type Function');
+
+  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+    var fn = original[kCustomPromisifiedSymbol];
+    if (typeof fn !== 'function') {
+      throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+    }
+    Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn, enumerable: false, writable: false, configurable: true
+    });
+    return fn;
+  }
+
+  function fn() {
+    var promiseResolve, promiseReject;
+    var promise = new Promise(function (resolve, reject) {
+      promiseResolve = resolve;
+      promiseReject = reject;
+    });
+
+    var args = [];
+    for (var i = 0; i < arguments.length; i++) {
+      args.push(arguments[i]);
+    }
+    args.push(function (err, value) {
+      if (err) {
+        promiseReject(err);
+      } else {
+        promiseResolve(value);
+      }
+    });
+
+    try {
+      original.apply(this, args);
+    } catch (err) {
+      promiseReject(err);
+    }
+
+    return promise;
+  }
+
+  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+
+  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+    value: fn, enumerable: false, writable: false, configurable: true
+  });
+  return Object.defineProperties(
+    fn,
+    Object.getOwnPropertyDescriptors(original)
+  );
+}
+
+exports.promisify.custom = kCustomPromisifiedSymbol