add /extra.js + refactor tests + improve async rejection chains

Author: alanclarke

README.md

@@ -5,7 +5,7 @@ A tiny sync promise lib
 sync-p is 52 lines of code, but handles the majority of the promise spec. Some of the spec is intentionally avoided, e.g.
 - sync-p is capable of returning synchronously, i.e. it does not defer everything
 - to avoid bloat sync-p assumes that truthy args passed to .then are functions (strict adherence involves explicitly handling cases like .then(5) ...like, just don't do that, that's not the api)
-- it doesn't handle the case where promise x is given a handler that returns promise x, causing an infinite promise recursion, because why would you ever do that
+- it does not throw if a promise is rejected and no reject handler is attached
 
 ## installation
 ```

deferred.js defer.js

@@ -1,7 +1,7 @@
-var promise = require('./index')
+var Promise = require('./index')
 module.exports = function deferred () {
   var _resolve, _reject
-  var _promise = promise(function (resolve, reject) {
+  var _promise = Promise(function (resolve, reject) {
     _resolve = resolve
     _reject = reject
   })

extra.js

@@ -0,0 +1,6 @@
+var Promise = require('./index')
+Promise.all = require('./all')
+Promise.resolve = require('./resolve')
+Promise.reject = require('./reject')
+Promise.defer = require('./defer')
+module.exports = Promise

index.js

@@ -1,8 +1,10 @@
 module.exports = function promise (resolver) {
   var waiting = { res: [], rej: [] }
-  var p = { 'then': then, 'catch': thenCatch }
   var reject = api(false)
   var resolve = api(true, reject)
+  var p = { 'then': then, 'catch': function thenCatch (onReject) {
+    return then(null, onReject)
+  }}
   try { resolver(resolve, reject) } catch (e) {
     p.status = false
     p.value = e
@@ -12,33 +14,30 @@ module.exports = function promise (resolver) {
   function api (status, reject) {
     return function end (val) {
       if (typeof p.status !== 'undefined') return
-      if (val === p) throw new Error('TypeError: recurses! infinite promise chain detected')
-      if (status && val && typeof val === 'object' && val.then) return val.then(resolve, reject)
+      if (val === p) throw new Error('Error: recurses! infinite promise chain detected')
+      if (status && val) try { if ('then' in val) return val.then(resolve, reject) } catch (e) {}
       p.status = status
       p.value = val
       flush()
     }
   }
 
   function then (onResolve, onReject) {
-    if (!onResolve && !onReject) return p
-    if (!onResolve && p.status === true) return p
-    if (!onReject && p.status === false) return p
     return chain(onResolve, onReject)
   }
 
-  function thenCatch (onReject) {
-    return then(null, onReject)
-  }
-
   function chain (onResolve, onReject) {
     return promise(function (resolve, reject) {
       waiting.res.push(handleNext(onResolve))
       waiting.rej.push(handleNext(onReject))
       flush()
       function handleNext (handler) {
         return function next (value) {
-          try { resolve(handler ? handler(value) : value) } catch (err) { reject(err) }
+          try {
+            value = handler ? handler(value) : value
+            if (p.status) return resolve(value)
+            return onReject ? resolve(value) : reject(value)
+          } catch (err) { reject(err) }
         }
       }
     })

rejected.js reject.js

@@ -1,15 +1,10 @@
 // // some of the spec is intentionally avoided, e.g.
 // // a) the lib is capable of returning syncronously, i.e. it does not defer everything
 // // b) to avoid bloat, the lib assumes non falsey args to be functions
-//
-// var resolved = require('../resolved')
-// var rejected = require('../rejected')
-// var deferred = require('../deferred')
-// var adapter = {
-//   resolved: resolved,
-//   rejected: rejected,
-//   deferred: deferred
-// }
-// describe("Promises/A+ Tests", function () {
-//   require("promises-aplus-tests").mocha(adapter)
+// describe('Promises/A+ Tests', function () {
+//   require('promises-aplus-tests').mocha({
+//     resolved: require('../resolve'),
+//     rejected: require('../reject'),
+//     deferred: require('../defer')
+//   })
 // })

resolved.js resolve.js

@@ -1,54 +1,44 @@
-/* globals describe it Promise */
+/* globals describe it */
 var expect = require('chai').expect
-var promise = require('../index')
-var all = require('../all')
+var Promise = require('../extra')
 
 describe('all', function () {
-  describe('empty array', function () {
+  describe('when called with an empty array', function () {
     it('should return immediately', function () {
       var values = []
       var result
-      all(values).then(function (val) {
+      Promise.all(values).then(function (val) {
         result = val
       })
       expect(result).to.eql(values)
     })
   })
-  describe('only values', function () {
+  describe('when called with just values', function () {
     it('should return immediately', function () {
       var values = [1, 2, 3]
       var result
-      all(values).then(function (val) {
+      Promise.all(values).then(function (val) {
         result = val
       })
       expect(result).to.eql(values)
     })
   })
-  describe('values and promises', function () {
-    it('should replace promised values with the values themselves', function (done) {
-      var values = [1, 2, later(3)]
-      return all(values).then(function (val) {
+  describe('when called with a mixture of values and promises', function () {
+    it('should resolve the promises and return only values', function (done) {
+      var values = [1, 2, Promise.resolve(3)]
+      Promise.all(values).then(function (val) {
         expect(val).to.eql([1, 2, 3])
         done()
       })
     })
   })
   describe('error', function () {
     it('should reject the promise', function (done) {
-      var values = [1, 2, later('error', true)]
-      return all(values).catch(function (val) {
-        expect(val).to.eql('error')
+      var values = [1, 2, Promise.reject('error')]
+      Promise.all(values).catch(function (err) {
+        expect(err).to.eql('error')
         done()
       })
     })
   })
 })
-
-function later (val, shouldReject) {
-  return promise(function (resolve, reject) {
-    setTimeout(function () {
-      if (shouldReject) return reject(val)
-      resolve(val)
-    }, 0)
-  })
-}

test/test-a-plus.js

@@ -1,97 +1,93 @@
-/* globals describe it Promise */
+/* globals describe it */
 var expect = require('chai').expect
 var sinon = require('sinon')
-var promise = require('../index')
+var Promise = require('../extra')
 
 describe('async reject', function () {
-  it('should resolve values', function (done) {
-    return promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(123)
-      }, 0)
-    })
-    .then(null, function (val) {
-      expect(val).to.eql(123)
-      done()
-    })
+  it('should call reject', function () {
+    var stub = sinon.stub()
+    var d = Promise.defer()
+    d.promise.then(null, stub)
+    d.reject(123)
+    expect(stub.calledWith(123)).to.eql(true)
   })
-  it('should be chainable', function (done) {
-    return promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(123)
-      }, 0)
-    })
-    .then(null, function () {
-      return 234
-    })
-    .then(function (chained) {
-      expect(chained).to.eql(234)
-      done()
-    })
+  it('should not call resolve', function () {
+    var stub = sinon.stub()
+    var d = Promise.defer()
+    d.promise.then(stub, null)
+    d.reject(123)
+    expect(stub.called).to.eql(false)
   })
-  it('should be really chainable', function (done) {
-    return promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(123)
-      }, 0)
-    })
-    .then(null, null)
-    .then(null, function () {
-      return 234
-    })
-    .then(function (chained) {
-      expect(chained).to.eql(234)
-      done()
-    })
+  it('should recover when caught', function () {
+    var stub = sinon.stub()
+    var d = Promise.defer()
+    d.promise
+      .then(null, function () { return 234 })
+      .then(stub, null)
+    d.reject(123)
+    expect(stub.calledWith(234)).to.eql(true)
   })
-  it('should not change once rejected', function (done) {
-    return promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(123)
-        reject(234)
-      }, 0)
-    })
-    .then(null, function (val) {
-      expect(val).to.eql(123)
-      done()
-    })
+  it('should be really chainable', function () {
+    var stub = sinon.stub()
+    var d = Promise.defer()
+    d.promise
+      .then(null, null)
+      .then(null, function () {
+        return 234
+      })
+      .then(stub)
+    d.reject(123)
+    expect(stub.calledWith(234)).to.eql(true)
+  })
+  it('should be really really chainable', function () {
+    var resolvedStub = sinon.stub()
+    var rejectedStub = sinon.stub()
+    var d = Promise.defer()
+    d.promise
+      .then(resolvedStub, null)
+      .then(null, rejectedStub)
+    d.reject(123)
+    expect(resolvedStub.called).to.eql(false)
+    expect(rejectedStub.calledWith(123)).to.eql(true)
   })
-  it('should not call resolve', function (done) {
+  it('should not change once rejected', function () {
     var stub = sinon.stub()
-    return promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(123)
-      }, 0)
-    })
-    .then(stub, function () {})
-    .then(function () {
-      expect(stub.called).to.eql(false)
-      done()
-    })
+    var d = Promise.defer()
+    d.promise.then(null, stub)
+    d.reject(123)
+    d.reject(234)
+    expect(d.promise.value).to.eql(123)
   })
-
-  // requires native Promise api
-  if (typeof Promise === 'undefined') return
-  it('should not resolve promises', function (done) {
-    return promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(Promise.resolve(123))
-      }, 0)
-    })
-    .then(null, function (val) {
-      expect(typeof val).to.eql('object')
-      done()
+  it('should reject an already fulfilled promise with the same reason', function () {
+    var stub = sinon.stub()
+    var d1 = Promise.defer()
+    var d2 = Promise.defer()
+    d1.promise.then(function () {
+      return d2.promise
     })
+    .then(null, stub)
+    d1.resolve()
+    d2.reject(123)
+    expect(stub.calledWith(123)).to.eql(true)
   })
-  it('should be compatible with the native promise api', function (done) {
-    return Promise.all([promise(function (resolve, reject) {
-      setTimeout(function () {
-        reject(123)
-      }, 0)
-    })])
-    .then(null, function (reason) {
-      expect(reason).to.eql(123)
-      done()
+  it('should reject an already rejected promise from a rejected promise with the same reason', function () {
+    var stub = sinon.stub()
+    var d1 = Promise.defer()
+    var d2 = Promise.defer()
+    d1.promise.then(null, function () {
+      return d2.promise
     })
+    .then(null, stub)
+    d1.reject()
+    d2.reject(123)
+    expect(stub.calledWith(123)).to.eql(true)
+  })
+  it('should not resolve promises', function () {
+    var p = Promise.resolve(123)
+    var stub = sinon.stub()
+    var d = Promise.defer()
+    d.promise.then(null, stub)
+    d.reject(p)
+    expect(stub.calledWith(p)).to.eql(true)
   })
 })