array.$loaded should wait for all promises to resolve. Closes #629.

When we added promise support for user-extendable functions in
`$firebaseArray`, the unintended consequense was that the `$loaded`
promise was resolving before updates from the server were populated
to the array. The solution is to accumulate any user returned promises,
and wait until they have all resolved.

Author: jamestalmage

src/FirebaseArray.js

@@ -47,8 +47,8 @@
    * var list = new ExtendedArray(ref);
    * </code></pre>
    */
-  angular.module('firebase').factory('$firebaseArray', ["$log", "$firebaseUtils",
-    function($log, $firebaseUtils) {
+  angular.module('firebase').factory('$firebaseArray', ["$log", "$firebaseUtils", "$q",
+    function($log, $firebaseUtils, $q) {
       /**
        * This constructor should probably never be called manually. It is used internally by
        * <code>$firebase.$asArray()</code>.
@@ -631,39 +631,46 @@
 
         var def     = $firebaseUtils.defer();
         var created = function(snap, prevChild) {
-          var rec = firebaseArray.$$added(snap, prevChild);
-          $firebaseUtils.whenUnwrapped(rec, function(rec) {
-            firebaseArray.$$process('child_added', rec, prevChild);
+          waitForResolution(firebaseArray.$$added(snap, prevChild), function(rec) {
+            firebaseArray.$$process('child_added', rec, prevChild)
           });
         };
         var updated = function(snap) {
           var rec = firebaseArray.$getRecord($firebaseUtils.getKey(snap));
           if( rec ) {
-            var res = firebaseArray.$$updated(snap);
-            $firebaseUtils.whenUnwrapped(res, function() {
+            waitForResolution(firebaseArray.$$updated(snap), function() {
               firebaseArray.$$process('child_changed', rec);
             });
           }
         };
         var moved   = function(snap, prevChild) {
           var rec = firebaseArray.$getRecord($firebaseUtils.getKey(snap));
           if( rec ) {
-            var res = firebaseArray.$$moved(snap, prevChild);
-            $firebaseUtils.whenUnwrapped(res, function() {
+            waitForResolution(firebaseArray.$$moved(snap, prevChild), function() {
               firebaseArray.$$process('child_moved', rec, prevChild);
             });
           }
         };
         var removed = function(snap) {
           var rec = firebaseArray.$getRecord($firebaseUtils.getKey(snap));
           if( rec ) {
-            var res = firebaseArray.$$removed(snap);
-            $firebaseUtils.whenUnwrapped(res, function() {
-              firebaseArray.$$process('child_removed', rec);
+            waitForResolution(firebaseArray.$$removed(snap), function() {
+               firebaseArray.$$process('child_removed', rec);
             });
           }
         };
 
+        function waitForResolution(maybePromise, callback) {
+          var promise = $q.when(maybePromise);
+          promise.then(function(result){
+            if (result) callback(result);
+          });
+          if (!isResolved) {
+            resolutionPromises.push(promise);
+          }
+        }
+
+        var resolutionPromises = [];
         var isResolved = false;
         var error   = $firebaseUtils.batch(function(err) {
           _initComplete(err);
@@ -677,7 +684,11 @@
           destroy: destroy,
           isDestroyed: false,
           init: init,
-          ready: function() { return def.promise; }
+          ready: function() { return def.promise.then(function(result){
+            return $q.all(resolutionPromises).then(function(){
+              return result;
+            });
+          }); }
         };
 
         return sync;

src/utils.js

@@ -182,16 +182,6 @@
 
           resolve: $q.when,
 
-          whenUnwrapped: function(possiblePromise, callback) {
-            if( possiblePromise ) {
-              utils.resolve(possiblePromise).then(function(res) {
-                if( res ) {
-                  callback(res);
-                }
-              });
-            }
-          },
-
           //TODO: Remove false branch and use only angular implementation when we drop angular 1.2.x support.
           promise: angular.isFunction($q) ? $q : Q,
 

tests/unit/FirebaseArray.spec.js

@@ -104,9 +104,37 @@ describe('$firebaseArray', function () {
       queue[0]('James');
       $timeout.flush();
       expect(arr.length).toBe(1);
-      expect(arr[0].name).toBe('James')
+      expect(arr[0].name).toBe('James');
     });
 
+    it('should wait to resolve $loaded until $$added promise is resolved', function () {
+      var queue = [];
+      function addPromise(snap, prevChild){
+        return new $utils.promise(
+          function(resolve) {
+            queue.push(resolve);
+          }).then(function(name) {
+            var data = $firebaseArray.prototype.$$added.call(arr, snap, prevChild);
+            data.name = name;
+            return data;
+          });
+      }
+      var called = false;
+      var ref = stubRef();
+      arr = stubArray(null, $firebaseArray.$extend({$$added:addPromise}), ref);
+      arr.$loaded().then(function(){
+        expect(arr.length).toBe(1);
+        called = true;
+      });
+      ref.set({'-Jwgx':{username:'James', email:'[email protected]'}});
+      ref.flush();
+      $timeout.flush();
+      queue[0]('James');
+      $timeout.flush();
+      expect(called, 'called').toBe(true);
+    });
+
+
     it('should reject promise on fail', function() {
       var successSpy = jasmine.createSpy('resolve spy');
       var errSpy = jasmine.createSpy('reject spy');