Update RSVP and RenderJS to latest version

lib/rsvp.js

@@ -60,7 +60,7 @@ define("rsvp/all",
         }
       }
 
-      return new Promise(function(resolve, reject, notify) {
+      return new Promise(function(resolve, reject) {
         var results = [], remaining = promises.length,
         promise, remaining_count = promises.length - expected_count;
 
@@ -90,12 +90,6 @@ define("rsvp/all",
           }
         }
 
-        function notifier(index) {
-          return function(value) {
-            notify({"index": index, "value": value});
-          };
-        }
-
         function cancelAll(rejectionValue) {
           reject(rejectionValue);
           canceller();
@@ -105,7 +99,7 @@ define("rsvp/all",
           promise = promises[i];
 
           if (promise && typeof promise.then === 'function') {
-            promise.then(resolver(i), cancelAll, notifier(i));
+            promise.then(resolver(i), cancelAll);
           } else {
             resolveAll(i, promise);
           }
@@ -135,6 +129,29 @@ define("rsvp/async",
     var async;
     var local = (typeof global !== 'undefined') ? global : this;
 
+    function checkNativePromise() {
+      if (typeof Promise === "function" &&
+          typeof Promise.resolve === "function") {
+        try {
+          /* global Promise */
+          var promise = new Promise(function(){});
+          if ({}.toString.call(promise) === "[object Promise]") {
+            return true;
+          }
+        } catch (e) {}
+      }
+      return false;
+    }
+
+    function useNativePromise() {
+      var nativePromise = Promise.resolve();
+      return function(callback, arg) {
+        nativePromise.then(function () {
+          callback(arg);
+        });
+      };
+    }
+
     // old node
     function useNextTick() {
       return function(callback, arg) {
@@ -190,7 +207,9 @@ define("rsvp/async",
       };
     }
 
-    if (typeof setImmediate === 'function') {
+    if (checkNativePromise()) {
+      async = useNativePromise();
+    } else if (typeof setImmediate === 'function') {
       async = useSetImmediate();
     } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
       async = useNextTick();
@@ -360,10 +379,10 @@ define("rsvp/events",
     __exports__.EventTarget = EventTarget;
   });
 define("rsvp/hash",
-  ["rsvp/defer","exports"],
+  ["rsvp/promise","exports"],
   function(__dependency1__, __exports__) {
     "use strict";
-    var defer = __dependency1__.defer;
+    var Promise = __dependency1__.Promise;
 
     function size(object) {
       var s = 0;
@@ -376,38 +395,61 @@ define("rsvp/hash",
     }
 
     function hash(promises) {
-      var results = {}, deferred = defer(), remaining = size(promises);
+
+      function canceller() {
+        var promise,
+          key;
+        for (key in promises) {
+          if (promises.hasOwnProperty(key)) {
+            promise = promises[key];
+
+            if (promise && typeof promise.then === 'function' &&
+                typeof promise.cancel === 'function') {
+              promise.cancel();
+            }
+          }
+        }
+      }
+
+      return new Promise(function(resolve, reject) {
+        var results = {}, remaining = size(promises),
+          promise;
 
         if (remaining === 0) {
-        deferred.resolve({});
+          resolve(results);
         }
 
-      var resolver = function(prop) {
+        function resolver(key) {
           return function(value) {
-          resolveAll(prop, value);
-        };
+            resolveAll(key, value);
           };
+        }
 
-      var resolveAll = function(prop, value) {
-        results[prop] = value;
+        function resolveAll(key, value) {
+          results[key] = value;
           if (--remaining === 0) {
-          deferred.resolve(results);
+            resolve(results);
+          }
         }
-      };
 
-      var rejectAll = function(error) {
-        deferred.reject(error);
-      };
+        function cancelAll(rejectionValue) {
+          reject(rejectionValue);
+          canceller();
+        }
 
         for (var prop in promises) {
-        if (promises[prop] && typeof promises[prop].then === 'function') {
-          promises[prop].then(resolver(prop), rejectAll);
+          promise = promises[prop];
+
+          if (promise && typeof promise.then === 'function') {
+            promise.then(resolver(prop), cancelAll);
           } else {
-          resolveAll(prop, promises[prop]);
+            resolveAll(prop, promise);
           }
         }
 
-      return deferred.promise;
+      }, canceller
+      );
+
     }
 
 
@@ -504,11 +546,6 @@ define("rsvp/promise",
         reject(promise, value);
       };
 
-      var notifyPromise = function(value) {
-        if (resolved) { return; }
-        notify(promise, value);
-      };
-
       this.on('promise:failed', function(event) {
         this.trigger('error', { detail: event.detail });
       }, this);
@@ -519,6 +556,7 @@ define("rsvp/promise",
         // For now, simply reject the promise and does not propagate the cancel
         // to parent or children
         if (resolved) { return; }
+        promise.isCancelled = true;
         if (canceller !== undefined) {
           try {
             canceller();
@@ -532,7 +570,7 @@ define("rsvp/promise",
       };
 
       try {
-        resolver(resolvePromise, rejectPromise, notifyPromise);
+        resolver(resolvePromise, rejectPromise);
       } catch(e) {
         rejectPromise(e);
       }
@@ -550,6 +588,7 @@ define("rsvp/promise",
 
       if (promise.isFulfilled) { return; }
       if (promise.isRejected) { return; }
+      if (promise.isCancelled) { return; }
 
       if (hasCallback) {
         try {
@@ -577,31 +616,16 @@ define("rsvp/promise",
       }
     };
 
-
-    var invokeNotifyCallback = function(promise, callback, event) {
-      var value;
-      if (typeof callback === 'function') {
-        try {
-          value = callback(event.detail);
-        } catch (e) {
-          // stop propagating
-          return;
-        }
-        notify(promise, value);
-      } else {
-        notify(promise, event.detail);
-      }
-    };
-
     Promise.prototype = {
       constructor: Promise,
 
+      isCancelled: undefined,
       isRejected: undefined,
       isFulfilled: undefined,
       rejectedReason: undefined,
       fulfillmentValue: undefined,
 
-      then: function(done, fail, progress) {
+      then: function(done, fail) {
         this.off('error', onerror);
 
         var thenPromise = new this.constructor(function() {},
@@ -629,10 +653,6 @@ define("rsvp/promise",
           invokeCallback('reject', thenPromise, fail, event);
         });
 
-        this.on('promise:notified', function (event) {
-          invokeNotifyCallback(thenPromise, progress, event);
-        });
-
         return thenPromise;
       },
 
@@ -720,21 +740,15 @@ define("rsvp/promise",
       });
     }
 
-    function notify(promise, value) {
-      config.async(function() {
-        promise.trigger('promise:notified', { detail: value });
-      });
-    }
-
 
     __exports__.Promise = Promise;
   });
 define("rsvp/queue",
-  ["rsvp/promise","rsvp/timeout","exports"],
+  ["rsvp/promise","rsvp/resolve","exports"],
   function(__dependency1__, __dependency2__, __exports__) {
     "use strict";
     var Promise = __dependency1__.Promise;
-    var delay = __dependency2__.delay;
+    var resolve = __dependency2__.resolve;
 
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
     function ResolvedQueueError(message) {
@@ -747,7 +761,7 @@ define("rsvp/queue",
     ResolvedQueueError.prototype = new Error();
     ResolvedQueueError.prototype.constructor = ResolvedQueueError;
 
-    var Queue = function() {
+    var Queue = function(thenable) {
       var queue = this,
         promise_list = [],
         promise,
@@ -760,9 +774,29 @@ define("rsvp/queue",
       }
 
       function canceller() {
-        for (var i = 0; i < 2; i++) {
-          promise_list[i].cancel();
+        for (var i = promise_list.length; i > 0; i--) {
+          promise_list[i - 1].cancel();
+        }
+      }
+
+      function checkPromise(next_promise) {
+        promise_list.push(next_promise);
+        // Handle pop
+        promise_list.push(next_promise.then(function (fulfillmentValue) {
+          promise_list.splice(0, 2);
+          if (promise_list.length === 0) {
+            fulfill(fulfillmentValue);
+          } else {
+            return fulfillmentValue;
+          }
+        }, function (rejectedReason) {
+          promise_list.splice(0, 2);
+          if (promise_list.length === 0) {
+            reject(rejectedReason);
+          } else {
+            throw rejectedReason;
           }
+        }));
       }
 
       promise = new Promise(function(done, fail) {
@@ -782,13 +816,7 @@ define("rsvp/queue",
         };
       }, canceller);
 
-      promise_list.push(delay());
-      promise_list.push(promise_list[0].then(function () {
-        promise_list.splice(0, 2);
-        if (promise_list.length === 0) {
-          fulfill();
-        }
-      }));
+      checkPromise(resolve(thenable));
 
       queue.cancel = function () {
         if (resolved) {return;}
@@ -811,25 +839,9 @@ define("rsvp/queue",
           throw new ResolvedQueueError();
         }
 
-        next_promise = last_promise.then(done, fail);
-        promise_list.push(next_promise);
-
         // Handle pop
-        promise_list.push(next_promise.then(function (fulfillmentValue) {
-          promise_list.splice(0, 2);
-          if (promise_list.length === 0) {
-            fulfill(fulfillmentValue);
-          } else {
-            return fulfillmentValue;
-          }
-        }, function (rejectedReason) {
-          promise_list.splice(0, 2);
-          if (promise_list.length === 0) {
-            reject(rejectedReason);
-          } else {
-            throw rejectedReason;
-          }
-        }));
+        checkPromise(last_promise.then(done, fail));
+
 
         return this;
       };