Es6 style promises

src/FirebaseAuth.js

@@ -222,24 +222,27 @@
      */
     _routerMethodOnAuthPromise: function(rejectIfAuthDataIsNull) {
       var ref = this._ref;
-      var deferred = this._q.defer();
 
-      function callback(authData) {
-        if (authData !== null) {
-          deferred.resolve(authData);
-        } else if (rejectIfAuthDataIsNull) {
-          deferred.reject("AUTH_REQUIRED");
-        } else {
-          deferred.resolve(null);
+      return this._utils.promise(function(resolve,reject){
+        function callback(authData) {
+          // Turn off this onAuth() callback since we just needed to get the authentication data once.
+          ref.offAuth(callback);
+
+          if (authData !== null) {
+            resolve(authData);
+            return;
+          }
+          else if (rejectIfAuthDataIsNull) {
+            reject("AUTH_REQUIRED");
+            return;
+          }
+          else {
+            resolve(null);
+          }
         }
 
-        // Turn off this onAuth() callback since we just needed to get the authentication data once.
-        ref.offAuth(callback);
-      }
-
-      ref.onAuth(callback);
-
-      return deferred.promise;
+        ref.onAuth(callback);
+      });
     },
 
     /**

src/firebase.js

@@ -128,16 +128,18 @@
             }
             applyLocally = !!applyLocally;
 
-            var def = $firebaseUtils.defer();
-            ref.transaction(valueFn, function(err, committed, snap) {
-               if( err ) {
-                 def.reject(err);
-               }
-               else {
-                 def.resolve(committed? snap : null);
-               }
-            }, applyLocally);
-            return def.promise;
+            return new $firebaseUtils.promise(function(resolve,reject){
+              ref.transaction(valueFn, function(err, committed, snap) {
+                if( err ) {
+                  reject(err);
+                  return;
+                }
+                else {
+                  resolve(committed? snap : null);
+                  return;
+                }
+              }, applyLocally);
+            });
           },
 
           $asObject: function () {

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');
+  });
+
+});