fix(mustache): fix regression that fired an initial empty string

Closes #734

lib/core_dom/directive.dart

@@ -1,10 +1,10 @@
 part of angular.core.dom;
 
 /// Callback function used to notify of attribute changes.
-typedef AttributeChanged(String newValue);
+typedef void AttributeChanged(String newValue);
 
 /// Callback function used to notify of observer changes.
-typedef void ObserverChanged(bool hasListeners);
+typedef void Mustache(bool hasObservers);
 
 /**
  * NodeAttrs is a facade for element attributes. The facade is responsible
@@ -16,13 +16,17 @@ class NodeAttrs {
 
   Map<String, List<AttributeChanged>> _observers;
 
-  Map<String, List<ObserverChanged>> _observerListeners;
+  Map<String, Mustache> _mustacheObservers = {};
+  Set<String> _mustacheComputedAttrs = new Set<String>();
 
   NodeAttrs(this.element);
 
   operator [](String attributeName) => element.attributes[attributeName];
 
   void operator []=(String attributeName, String value) {
+    if (_mustacheObservers.containsKey(attributeName)) {
+      _mustacheComputedAttrs.add(attributeName);
+    }
     if (value == null) {
       element.attributes.remove(attributeName);
     } else {
@@ -43,11 +47,15 @@ class NodeAttrs {
     _observers.putIfAbsent(attributeName, () => <AttributeChanged>[])
               .add(notifyFn);
 
-    notifyFn(this[attributeName]);
+    bool hasMustache = _mustacheObservers.containsKey(attributeName);
+    bool hasMustacheAndIsComputed = _mustacheComputedAttrs.contains(attributeName);
+
+    if (!hasMustache || hasMustacheAndIsComputed) {
+      notifyFn(this[attributeName]);
+    }
 
-    if (_observerListeners != null &&
-        _observerListeners.containsKey(attributeName)) {
-      _observerListeners[attributeName].forEach((cb) => cb(true));
+    if (_mustacheObservers.containsKey(attributeName)) {
+      _mustacheObservers[attributeName](true);
     }
   }
 
@@ -60,12 +68,8 @@ class NodeAttrs {
 
   Iterable<String> get keys => element.attributes.keys;
 
-  void listenObserverChanges(String attributeName, ObserverChanged fn) {
-    if (_observerListeners == null) {
-      _observerListeners = <String, List<ObserverChanged>>{};
-    }
-    _observerListeners.putIfAbsent(attributeName, () => <ObserverChanged>[])
-                      .add(fn);
+  void listenObserverChanges(String attributeName, Mustache fn) {
+    _mustacheObservers[attributeName] = fn;
     fn(false);
   }
 }

test/core_dom/ng_mustache_spec.dart

@@ -7,6 +7,7 @@ main() {
     TestBed _;
     beforeEachModule((Module module) {
       module.type(_HelloFilter);
+      module.type(_FooDirective);
     });
     beforeEach(inject((TestBed tb) => _ = tb));
 
@@ -23,6 +24,23 @@ main() {
       expect(element.text()).toEqual('OK!');
     }));
 
+    describe('observe/flush phase', () {
+      it('should first only when then value has settled', async((Logger log) {
+        _.compile('<div dir-foo="{{val}}"></div>');
+
+        _.rootScope.apply();
+        // _FooDirective should NOT have observed any changes.
+        expect(log).toEqual([]);
+        expect(_.rootElement.attributes['dir-foo']).toEqual('');
+
+        _.rootScope.apply(() {
+          _.rootScope.context['val'] = 'value';
+        });
+        // _FooDirective should have observed exactly one change.
+        expect(_.rootElement.attributes['dir-foo']).toEqual('value');
+        expect(log).toEqual(['value']);
+      }));
+    });
 
     it('should replace {{}} in attribute', inject((Compiler $compile, Scope rootScope, Injector injector, DirectiveMap directives) {
       var element = $('<div some-attr="{{name}}" other-attr="{{age}}"></div>');
@@ -117,3 +135,15 @@ class _HelloFilter {
   }
 }
 
+@NgComponent(selector: '[dir-foo]')
+class _FooDirective implements NgAttachAware {
+  NodeAttrs attrs;
+  Logger log;
+
+  _FooDirective(this.attrs, this.log);
+
+  @override
+  void attach() {
+    attrs.observe('dir-foo', (val) => log(val));
+  }
+}

test/directive/ng_src_boolean_spec.dart

@@ -93,18 +93,17 @@ main() {
     TestBed _;
     beforeEach((TestBed tb) => _ = tb);
 
-    it('should interpolate the expression and bind to src with raw same-domain value',
-    inject(() {
+    it('should interpolate the expression and bind to src with raw same-domain value', () {
       _.compile('<div ng-src="{{id}}"></div>');
 
       _.rootScope.apply();
-      expect(_.rootElement.attributes['src']).toEqual('');
+      expect(_.rootElement.attributes['src']).toEqual(null);
 
       _.rootScope.apply(() {
         _.rootScope.context['id'] = '/somewhere/here';
       });
       expect(_.rootElement.attributes['src']).toEqual('/somewhere/here');
-    }));
+    });
 
 
     xit('should interpolate the expression and bind to src with a trusted value', ($sce) {