Add polyfil for angular 1.3.x/ES6 style promises.

Angular 1.3.x introduced ES6 style promises. These often provide much cleaner / more concise code.
This commit provides a polyfill for that functionality that will use angulars implementation if available.

Author: jamestalmage

src/utils.js

@@ -25,6 +25,29 @@
 
     .factory('$firebaseUtils', ["$q", "$timeout", "firebaseBatchDelay",
       function($q, $timeout, firebaseBatchDelay) {
+
+        // ES6 style promises polyfill for angular 1.2.x
+        // Copied from angular 1.3.x implementation: https://github.com/angular/angular.js/blob/v1.3.5/src/ng/q.js#L539
+        function Q(resolver) {
+          if (!angular.isFunction(resolver)) {
+            throw new Error('missing resolver function');
+          }
+
+          var deferred = $q.defer();
+
+          function resolveFn(value) {
+            deferred.resolve(value);
+          }
+
+          function rejectFn(reason) {
+            deferred.reject(reason);
+          }
+
+          resolver(resolveFn, rejectFn);
+
+          return deferred.promise;
+        }
+
         var utils = {
           /**
            * Returns a function which, each time it is invoked, will pause for `wait`
@@ -220,21 +243,14 @@
             });
           },
 
-          defer: function() {
-            return $q.defer();
-          },
+          defer: $q.defer,
 
-          reject: function(msg) {
-            var def = utils.defer();
-            def.reject(msg);
-            return def.promise;
-          },
+          reject: $q.reject,
 
-          resolve: function() {
-            var def = utils.defer();
-            def.resolve.apply(def, arguments);
-            return def.promise;
-          },
+          resolve: $q.when,
+
+          //TODO: Remove false branch and use only angular implementation when we drop angular 1.2.x support.
+          promise: angular.isFunction($q) ? $q : Q,
 
           makeNodeResolver:function(deferred){
             return function(err,result){

tests/unit/utils.spec.js

@@ -254,3 +254,67 @@ describe('$firebaseUtils', function () {
   });
 
 });
+
+describe('#promise (ES6 Polyfill)', function(){
+
+  var status, result, reason, $utils, $timeout;
+
+  function wrapPromise(promise){
+    promise.then(function(_result){
+      status = 'resolved';
+      result = _result;
+    },function(_reason){
+      status = 'rejected';
+      reason = _reason;
+    });
+  }
+
+  beforeEach(function(){
+    status = 'pending';
+    result = null;
+    reason = null;
+  });
+
+  beforeEach(module('firebase',function($provide){
+    $provide.decorator('$q',function($delegate){
+      //Forces polyfil even if we are testing against angular 1.3.x
+      return {
+        defer:$delegate.defer,
+        all:$delegate.all
+      }
+    });
+  }));
+
+  beforeEach(inject(function(_$firebaseUtils_, _$timeout_){
+    $utils = _$firebaseUtils_;
+    $timeout = _$timeout_;
+  }));
+
+  it('throws an error if not called with a function',function(){
+    expect(function(){
+      $utils.promise();
+    }).toThrow();
+    expect(function(){
+      $utils.promise({});
+    }).toThrow();
+  });
+
+  it('calling resolve will resolve the promise with the provided result',function(){
+    wrapPromise(new $utils.promise(function(resolve,reject){
+      resolve('foo');
+    }));
+    $timeout.flush();
+    expect(status).toBe('resolved');
+    expect(result).toBe('foo');
+  });
+
+  it('calling reject will reject the promise with the provided reason',function(){
+    wrapPromise(new $utils.promise(function(resolve,reject){
+      reject('bar');
+    }));
+    $timeout.flush();
+    expect(status).toBe('rejected');
+    expect(reason).toBe('bar');
+  });
+
+});