feat(scope): Automatically $digest futures inside of $apply.

Author: jbdeboer

lib/angular.dart

@@ -166,7 +166,8 @@ bootstrapAngular(modules, [rootElementSelector = '[ng-app]']) {
   Injector injector = new Injector(modules);
 
   injector.invoke((Compiler $compile, Scope $rootScope) {
-    $compile(topElt)(injector, topElt);
-    $rootScope.$digest();
+    $rootScope.$apply(() {
+      $compile(topElt)(injector, topElt);
+    });
   });
 }

lib/block.dart

@@ -303,7 +303,6 @@ class _ComponentFactory {
   attachBlockToShadowDom(BlockFactory blockFactory) {
     var block = blockFactory(shadowInjector);
     shadowDom.nodes.addAll(block.elements);
-    shadowInjector.get(Scope).$digest();
     return shadowDom;
   }
 

lib/directives/ng_include.dart

@@ -47,9 +47,6 @@ class NgIncludeAttrDirective {
         // an url template
         blockCache.fromUrl(value).then((createBlock) {
           updateContent(createBlock);
-
-          // Http should take care of this
-          scope.$digest();
         });
       }
     });

lib/scope.dart

@@ -173,6 +173,8 @@ class Scope implements Map {
   }
 
 
+
+
   $digest() {
     var value, last,
         asyncQueue = _asyncQueue,
@@ -283,20 +285,53 @@ class Scope implements Map {
 
 
   $apply([expr]) {
-    try {
-      _beginPhase('\$apply');
-      return $eval(expr);
-    } catch (e, s) {
-      _exceptionHandler(e, s);
-    } finally {
-      _clearPhase();
+    var toThrow;
+    var returnValue;
+    bool executingAsyncCallback = false;
+    async.runZonedExperimental(() {
       try {
-        $root.$digest();
+        _beginPhase('\$apply');
+        returnValue = $eval(expr);
       } catch (e, s) {
         _exceptionHandler(e, s);
-        throw e;
+      } finally {
+        _clearPhase();
+        try {
+          $root.$digest();
+        } catch (e, s) {
+          _exceptionHandler(e, s);
+          throw e;
+        }
+      }
+    }, onRunAsync: (fn) {
+      async.runAsync(() {
+        // exceptions from fn() can not be caught here, but
+        // are handled by onError.
+        executingAsyncCallback = true;
+        fn();
+        executingAsyncCallback = false;
+        try {
+          $root.$digest();
+        } catch (e, s) {
+          _exceptionHandler(e, s);
+        }
+      });
+    },
+    onError: (e) {
+      if (executingAsyncCallback) {
+        // NOTE(deboer): Thrown strings don't have an attached stack trace
+        // http://dartbug.com/12000
+        _exceptionHandler(e, async.getAttachedStackTrace(e));
       }
+      if (toThrow == null)
+        toThrow = e;
+    });
+    // This will only throw exceptions from the runZoned body.
+    // The async code will be executed after this check.
+    if (toThrow != null) {
+      throw toThrow;
     }
+    return returnValue;
   }
 
 

test/compiler_spec.dart

@@ -232,8 +232,9 @@ main() {
         $rootScope.sep = '-';
         var element = $(r'<div>{{name}}{{sep}}{{$id}}:<simple>{{name}}{{sep}}{{$id}}</simple></div>');
         BlockFactory blockFactory = $compile(element);
-        Block block = blockFactory(injector, element);
-        $rootScope.$digest();
+        $rootScope.$apply(() {
+          Block block = blockFactory(injector, element);
+        });
 
         nextTurn();
         expect(element.textWithShadow()).toEqual('OUTTER-_1:INNER_2(OUTTER-_1)');
@@ -244,15 +245,19 @@ main() {
         $rootScope.val = "poof";
         var element = $('<parent-expression from-parent=val></parent-expression>');
 
-        $compile(element)(injector, element);
+        $rootScope.$apply(() {
+          $compile(element)(injector, element);
+        });
 
         nextTurn();
         expect(renderedText(element)).toEqual('inside poof');
       })));
 
       it('should behave nicely if a mapped attribute is missing', async(inject(() {
         var element = $('<parent-expression></parent-expression>');
-        $compile(element)(injector, element);
+        $rootScope.$apply(() {
+          $compile(element)(injector, element);
+        });
 
         nextTurn();
         expect(renderedText(element)).toEqual('inside ');
@@ -261,7 +266,9 @@ main() {
       it('should behave nicely if a mapped attribute evals to null', async(inject(() {
         $rootScope.val = null;
         var element = $('<parent-expression fromParent=val></parent-expression>');
-        $compile(element)(injector, element);
+        $rootScope.$apply(() {
+          $compile(element)(injector, element);
+        });
 
         nextTurn();
         expect(renderedText(element)).toEqual('inside ');
@@ -311,10 +318,11 @@ main() {
         }, throwsA(contains('No provider found for LocalAttrDirective! (resolving LocalAttrDirective)')));
       }));
 
-      it('should publish component controller into the scope', async(inject(() {
+      it('should publish component controller into the scope', async(inject((Scope $rootScope) {
         var element = $(r'<div><publish-me></publish-me></div>');
-        $compile(element)(injector, element);
-        $rootScope.$apply();
+        $rootScope.$apply(() {
+          $compile(element)(injector, element);
+        });
 
         nextTurn();
         expect(element.textWithShadow()).toEqual('WORKED');

test/scope_spec.dart

@@ -1,4 +1,5 @@
 import "_specs.dart";
+import "dart:async";
 
 main() {
   describe(r'Scope', () {
@@ -482,6 +483,95 @@ main() {
         });
       });
 
+      describe(r'async', () {
+        beforeEach(module((AngularModule module) {
+          return module.type(ExceptionHandler, LogExceptionHandler);
+        }));
+
+        
+        it(r'should run watch cycle on future resolution', async(inject((Scope scope) {
+          var log = '';
+          scope['r'] = 0;
+          scope['qq'] = 0;
+          scope.$watch('q', (_) {
+            log += 'q';
+            scope['qq'] = 1;
+            new Future.value('b').then((v) {
+              log += 'b';
+              scope['r'] = 3;
+            });
+          });
+
+          scope.$watch('r', (rVal) {
+            log += 'r';
+            scope['s'] = rVal * 2;
+          });
+          scope.$apply("q=2");
+          expect(scope['qq']).toEqual(1);
+          expect(scope['q']).toEqual(2);
+          expect(scope['r']).toEqual(0);
+          expect(log).toEqual('qr');
+          nextTurn(true);
+
+          expect(scope['r']).toEqual(3);
+          expect(scope['s']).toEqual(6);
+          expect(log).toEqual('qrbr');
+        })));
+
+
+        it(r'should catch exceptions from futures', async(inject((Scope scope, ExceptionHandler $exceptionHandler) {
+          scope.$watch('q', (_) {
+            scope['qq'] = 1;
+            new Future.value('b').then((v) {
+              throw "sadface";
+            });
+          });
+          scope.$apply("q=2");
+          nextTurn(true);
+          expect($exceptionHandler.errors.length).toEqual(1);
+          expect($exceptionHandler.errors[0].error).toEqual("sadface");
+        })));
+
+
+        it(r'should catch exceptions from digests trigger by futures', async(inject((Scope scope, ExceptionHandler $exceptionHandler) {
+          scope.$watch('q', (_) {
+            scope['qq'] = 1;
+            new Future.value('b').then((v) {
+              scope['x'] = 2;
+            });
+          });
+          scope.$watch('x', (xVal) {
+            if (xVal == 2) throw "x was 2";
+          });
+          scope.$apply("q=2");
+          nextTurn(true);
+          expect($exceptionHandler.errors.length).toEqual(1);
+          expect($exceptionHandler.errors[0].error).toEqual("x was 2");
+        })));
+
+
+        it(r'should throw from the synchronous code', () {
+          module((AngularModule module) {
+            return module.type(ExceptionHandler, ExceptionHandler);
+          });
+
+          async(inject((Scope scope, ExceptionHandler $exceptionHandler) {
+            scope.$watch('q', (_) {
+            scope['qq'] = 1;
+            new Future.value('b').then((v) {
+              scope['x'] = 2;
+            });
+            throw "sync throw";
+          });
+          expect(() {
+            scope.$apply("q=2");
+            nextTurn(true);
+          }).toThrow('sync throw');
+
+          }));
+        });
+      });
+
 
       describe(r'exceptions', () {
         var log;