hybridables / redolent Goto Github PK

View Code? Open in Web Editor NEW

3.0 3.0 0.0 135 KB

Simple promisify with sane defaults, works on node 0.10 if you provide custom Promise through options

Home Page: http://j.mp/1LLnFgE

License: MIT License

JavaScript 100.00%

async callback custom es2015 native promises promisify sane-defaults simple synchronous utils

redolent's People

Contributors

Stargazers

Watchers

redolent's Issues

Resolve an interesting case

When for example, there is done argument, but is not called, and there is a result which is a promise.

something like

if (isAsyncFn && !called && isPromise(syncResult)) {
  resolve(syncResult)
}

https://github.com/hybridables/redolent/blob/master/index.js#L117-L124

edit:

this seems to fix it

      if ((!isAsyncFn && !called) || (isAsyncFn && !called && isPromise(syncResult))) {
        resolve(syncResult);
      }

i think we should handle this case, in that way. It is a lot better to auto-magically do it, instead of returning rejected promise that signals the user that he didn't called the done callback argument.

add `multipleArgs` false option

should be true by default, e.g. multipleArgs !== false on L59 if statement

Should promisified function return rejected promise when `done` is not called, but returns a non Promise value

e.g.

var fn = redolent(function (done) {
  return 'foo bar'
})

fn().catch(function (err) {
  console.log(err)
})

It can only return a Promise or undefined, or call the callback.

in these cases it not rejects

var fn = redolent(function (done) {
  return
})

var fn = redolent(function (done) {
  return undefined
})

use `lazy-cache`

for more lazyness, add browserify-friendly utils.js file

feat/bug: Reject when function is async but not `done` called nor Promise returned

Almost the same as #18

if (isAsyncFn && !called && !isPromise(syncResult)) {
  var msg = 'async function need to call `done/cb` callback argument or return a Promise'
  reject(new Error('redolent: ' + msg))
}

for example

var fn = redolent(function (foo, done) {
  console.log('foo is', foo)
  // done is not called nor Promise is returned,
  // so when `fn` is called it will return rejected promise 
})

fn(123).catch(console.log)

Return rejected error if no native promise support and no custom is given

Currently it will return rejected promise too, but with no so clear message - boolean is not a function which means nothing to the user.

move to `hybridables`

Because it is one of the main mechanisms behind the new wave of hybrids and upcoming stable v1 releases cycle.

Test ticket from Code Climate

tests for generators

for example

var fn = redolent(function * () {return yield args})
fn(1, 2, 3).then(console.log) // => [1, 2, 3]

skip last argument only if it `is-async-function`

hybridables/always-promise#4

dont work properly for optional arguments for core sync functions (fs.readFileSync)

because always pass "callback" function and when sync function is given optional arguments it throws

TypeError: Expected options to be either an object or a string, but got function instead

rised hybridables/letta#2

Test ticket from Code Climate

refactor / v2

same as letta
pass co@4 tests
handle unhandledRejection and uncaughtException events (* remove them from [email protected])
based on updated letta (0.6?)
has .promisify method
~~use it in hybridify@2 hybridables/hybridify#4~~ (use letta)
~~use it in callback2stream hybridables/callback2stream#7~~ (use letta)

allow getting Promise Ctor through `.load` (?) method

so we can just

var PromiseCtor = redolent.load()
// or
var PromiseCtor = redolent.load(require('bluebird')) // or some other promise

working code from the bundle (index$10 is NativePromise, index$6 extend-shallow)

function loadPromise (Promize) {
  var promCtor = index$10 || Promize
  if (typeof promCtor !== 'function') {
    throw new TypeError('redolent: no native Promise support and no opts.Promise')
  }
  return promCtor
}

var index = function redolent (fn, opts) {
  if (typeof fn !== 'function') {
    throw new TypeError('redolent: expect `fn` to be a function')
  }

  opts = index$6({
    context: this,
    Promise: index$10
  }, opts);
  opts.Promise = loadPromise(opts.Promise)


  module.exports.Promise = opts.Promise
  redolent.Promise = opts.Promise
  index.Promise = opts.Promise

  return function () {
    opts.context = this || opts.context;
    opts.args = index$2(opts.args).concat(index$4(arguments));

    // if (typeof opts.Promise !== 'function') {
    //   throw new TypeError('redolent: no native Promise support and no opts.Promise')
    // }

    var promise = new opts.Promise(function (resolve, reject) {
      var called = false;

      function done (er, res) {
        called = true;
        if (er) {
          return reject(er)
        }
        if (arguments.length > 2) {
          res = index$4(arguments, 1);
        }
        return resolve(res)
      }

      var isAsyncFn = index$12(fn);

      opts.args = isAsyncFn ? opts.args.concat(done) : opts.args;
      var syncResult = fn.apply(opts.context, opts.args);

      if (!isAsyncFn && !called) {
        resolve(syncResult);
      }
    });

    return normalize(promise, index$10)
  }
};

function normalize (promise, isNativeSupported) {
  promise.___nativePromise = Boolean(isNativeSupported);
  promise.___customPromise = !promise.___nativePromise;
  return promise
}

index.load = loadPromise
module.exports = index;

hybridables / redolent Goto Github PK

redolent's People

Contributors

Stargazers

Watchers

redolent's Issues

Recommend Projects

Recommend Topics

Recommend Org