fix(introspection): fix ngProbe with introspected bindings and findElements returning only elements

This change
1) organizes the introspection unit tests to more clearly separate them into
elementProbe tests and testability tests.

2) Modifies `interpolate` to return an `Interpolation` object which contains the
interpolated string and a list of binding expressions.

3) Adds an optional third parameter to findElements and findBindings which makes
the returned list include only elements or both elements and nodes (in practice,
these are text nodes). This defaults to only returning elements.

Author: juliemr

lib/core/interpolate.dart

@@ -1,5 +1,14 @@
 part of angular.core_internal;
 
+class Interpolation {
+  final String expression;
+  final List<String> bindingExpressions;
+
+  Interpolation(this.expression, this.bindingExpressions);
+}
+
+final EMPTY_INTERPOLATION = new Interpolation("", <String>[]);
+
 /**
  * Compiles a string with markup into an expression. This service is used by the
  * HTML [Compiler] service for data binding.
@@ -15,6 +24,7 @@ class Interpolate implements Function {
   Interpolate(CacheRegister cacheRegister) {
     cacheRegister.registerCache("Interpolate", _cache);
   }
+
   /**
    * Compiles markup text into expression.
    *
@@ -25,19 +35,18 @@ class Interpolate implements Function {
    * - [startSymbol]: The symbol to start interpolation. '{{' by default.
    * - [endSymbol]: The symbol to end interpolation. '}}' by default.
    */
-
-  String call(String template, [bool mustHaveExpression = false,
-              String startSymbol = '{{', String endSymbol = '}}']) {
+  Interpolation call(String template, [bool mustHaveExpression = false,
+                            String startSymbol = '{{', String endSymbol = '}}']) {
     if (mustHaveExpression == false && startSymbol == '{{' && endSymbol == '}}') {
       // cachable
       return _cache.putIfAbsent(template, () => _call(template, mustHaveExpression, startSymbol, endSymbol));
     }
     return _call(template, mustHaveExpression, startSymbol, endSymbol);
   }
 
-  String _call(String template, [bool mustHaveExpression = false,
-              String startSymbol, String endSymbol]) {
-    if (template == null || template.isEmpty) return "";
+  Interpolation _call(String template, [bool mustHaveExpression = false,
+                      String startSymbol, String endSymbol]) {
+    if (template == null || template.isEmpty) return EMPTY_INTERPOLATION;
 
     final startLen = startSymbol.length;
     final endLen = endSymbol.length;
@@ -51,6 +60,7 @@ class Interpolate implements Function {
 
     String exp;
     final expParts = <String>[];
+    final bindings = <String>[];
 
     while (index < length) {
       startIdx = template.indexOf(startSymbol, index);
@@ -61,7 +71,9 @@ class Interpolate implements Function {
           // formatter
           expParts.add(_wrapInQuotes(template.substring(index, startIdx)));
         }
-        expParts.add('(' + template.substring(startIdx + startLen, endIdx) + '|stringify)');
+        var binding = template.substring(startIdx + startLen, endIdx);
+        bindings.add(binding);
+        expParts.add('(' + binding + '|stringify)');
 
         index = endIdx + endLen;
         hasInterpolation = true;
@@ -72,7 +84,8 @@ class Interpolate implements Function {
       }
     }
 
-    return !mustHaveExpression || hasInterpolation ? expParts.join('+') : null;
+    return !mustHaveExpression || hasInterpolation ?
+        new Interpolation(expParts.join('+'), bindings) : null;
   }
 
   String _wrapInQuotes(String s){

lib/core_dom/common.dart

@@ -29,8 +29,9 @@ class DirectiveRef {
   final String value;
   final AST valueAST;
   final mappings = <MappingParts>[];
+  final List<String> bindingExpressions;
 
-  DirectiveRef(this.element, type, this.annotation, this.typeKey, [ this.value, this.valueAST ])
+  DirectiveRef(this.element, type, this.annotation, this.typeKey, [ this.value, this.valueAST, this.bindingExpressions ])
       : type = type,
         factory = Module.DEFAULT_REFLECTOR.factoryFor(type),
         paramKeys = Module.DEFAULT_REFLECTOR.parameterKeysFor(type);

lib/core_dom/element_binder.dart

@@ -296,8 +296,8 @@ class ElementBinder {
         DirectiveBinderFn config = ref.annotation.module;
         if (config != null) config(nodeInjector);
       }
-      if (_config.elementProbeEnabled && ref.valueAST != null) {
-        nodeInjector.elementProbe.bindingExpressions.add(ref.valueAST.expression);
+      if (_config.elementProbeEnabled && ref.bindingExpressions != null) {
+        nodeInjector.elementProbe.bindingExpressions.addAll(ref.bindingExpressions);
       }
     }
 

lib/core_dom/selector.dart

@@ -105,10 +105,10 @@ class DirectiveSelector {
           // the value. Yes it is a bit of a hack.
           _directives[selectorRegExp.selector].forEach((DirectiveTypeTuple tuple) {
             // Pre-compute the AST to watch this value.
-            String expression = _interpolate(value);
-            AST valueAST = _astParser(expression, formatters: _formatters);
+            Interpolation interpolation = _interpolate(value);
+            AST valueAST = _astParser(interpolation.expression, formatters: _formatters);
             builder.addDirective(new DirectiveRef(
-                node, tuple.type, tuple.directive, new Key(tuple.type), attrName, valueAST));
+                node, tuple.type, tuple.directive, new Key(tuple.type), attrName, valueAST, interpolation.bindingExpressions));
           });
         }
       }
@@ -143,11 +143,11 @@ class DirectiveSelector {
       if (selectorRegExp.regexp.hasMatch(value)) {
         _directives[selectorRegExp.selector].forEach((tuple) {
           // Pre-compute the AST to watch this value.
-          String expression = _interpolate(value);
-          var valueAST = _astParser(expression, formatters: _formatters);
+          Interpolation interpolation = _interpolate(value);
+          var valueAST = _astParser(interpolation.expression, formatters: _formatters);
 
           builder.addDirective(new DirectiveRef(node, tuple.type,
-              tuple.directive, new Key(tuple.type), value, valueAST));
+              tuple.directive, new Key(tuple.type), value, valueAST, interpolation.bindingExpressions));
         });
       }
     }

lib/directive/ng_pluralize.dart

@@ -168,7 +168,7 @@ class NgPluralize {
   void _setAndWatch(template) {
     if (_watch != null) _watch.remove();
     var expression = _expressionCache.putIfAbsent(template, () =>
-        _interpolate(template, false, r'${', '}'));
+        _interpolate(template, false, r'${', '}').expression);
     _watch = _scope.watch(expression, _updateMarkup, formatters: _formatters);
   }
 

lib/introspection.dart

@@ -73,6 +73,14 @@ List<ElementProbe> _findAllProbesInTree(dom.Node node) {
 }
 
 
+dom.Element _nearestElementAncestory(dom.Node node) {
+  if (node.nodeType == dom.Node.ELEMENT_NODE) {
+    return node;
+  } else {
+    return _nearestElementAncestory(node.parentNode);
+  }
+}
+
 /**
  * Return the [ElementProbe] object for the closest [Element] in the hierarchy.
  *
@@ -279,30 +287,42 @@ class _Testability implements _JsObjectProxyable {
    * Returns a list of all nodes in the selected tree that have an `ng-model`
    * binding specified by the [modelString].  If the optional [exactMatch]
    * parameter is provided and true, it restricts the searches to bindings that
-   * are exact matches for [modelString].
+   * are exact matches for [modelString].  If the optional [allowNonElementNodes]
+   * parameter is true, returned values will be the nearest parent node which is
+   * an element.
    */
-  List<dom.Node> findModels(String modelString, [bool exactMatch]) => _findByExpression(
-      modelString, exactMatch, (ElementProbe probe) => probe.modelExpressions);
+  List<dom.Node> findModels(String modelString, [bool exactMatch, bool allowNonElementNodes]) => _findByExpression(
+      modelString, exactMatch, allowNonElementNodes, (ElementProbe probe) => probe.modelExpressions);
 
   /**
    * Returns a list of all nodes in the selected tree that have `ng-bind` or
    * mustache bindings specified by the [bindingString].  If the optional
    * [exactMatch] parameter is provided and true, it restricts the searches to
-   * bindings that are exact matches for [bindingString].
+   * bindings that are exact matches for [bindingString].  If the optional
+   * [allowNonElementNodes] parameter is true, returned values will be the nearest parent
+   * node which is an element.
    */
-  List<dom.Node> findBindings(String bindingString, [bool exactMatch]) => _findByExpression(
-      bindingString, exactMatch, (ElementProbe probe) => probe.bindingExpressions);
+  List<dom.Node> findBindings(String bindingString, [bool exactMatch, bool allowNonElementNodes]) => _findByExpression(
+      bindingString, exactMatch, allowNonElementNodes, (ElementProbe probe) => probe.bindingExpressions);
+
+  List<dom.Node> _findByExpression(String query, bool exactMatch, bool allowNonElementNodes, _GetExpressionsFromProbe getExpressions) {
 
-  List<dom.Node> _findByExpression(String query, bool exactMatch, _GetExpressionsFromProbe getExpressions) {
     List<ElementProbe> probes = _findAllProbesInTree(node);
     if (probes.length == 0) {
       probes.add(_findProbeWalkingUp(node));
     }
     List<dom.Node> results = [];
     for (ElementProbe probe in probes) {
       for (String expression in getExpressions(probe)) {
-        if(exactMatch == true ? expression == query : expression.indexOf(query) >= 0) {
-          results.add(probe.element);
+        if (exactMatch == true ? expression == query : expression.indexOf(query) >= 0) {
+          if (allowNonElementNodes == true) {
+            results.add(probe.element);
+          } else {
+            var nearestElement = _nearestElementAncestory(probe.element);
+            if (!results.contains(nearestElement)) {
+              results.add(nearestElement);
+            }
+          }
         }
       }
     }
@@ -319,10 +339,10 @@ class _Testability implements _JsObjectProxyable {
   js.JsObject _toJsObject() {
     return _jsify({
         'allowAnimations': allowAnimations,
-        'findBindings': (bindingString, [exactMatch]) =>
-            findBindings(bindingString, exactMatch),
-        'findModels': (modelExpressions, [exactMatch]) =>
-            findModels(modelExpressions, exactMatch),
+        'findBindings': (bindingString, [exactMatch, allowNonElementNodes]) =>
+            findBindings(bindingString, exactMatch, allowNonElementNodes),
+        'findModels': (modelExpressions, [exactMatch, allowNonElementNodes]) =>
+            findModels(modelExpressions, exactMatch, allowNonElementNodes),
         'whenStable': (callback) =>
             whenStable(() => callback.apply([])),
         'notifyWhenNoOutstandingRequests': (callback) {

test/core/interpolate_spec.dart

@@ -15,27 +15,34 @@ main() {
     });
 
     it('should return an expression', (Interpolate interpolate) {
-      expect(interpolate('Hello {{name}}!'))
+      expect(interpolate('Hello {{name}}!').expression)
           .toEqual('"Hello "+(name|stringify)+"!"');
-      expect(interpolate('a{{b}}C'))
+      expect(interpolate('a{{b}}C').expression)
           .toEqual('"a"+(b|stringify)+"C"');
-      expect(interpolate('a{{b}}')).toEqual('"a"+(b|stringify)');
-      expect(interpolate('{{a}}b')).toEqual('(a|stringify)+"b"');
-      expect(interpolate('{{b}}')).toEqual('(b|stringify)');
-      expect(interpolate('{{b}}+{{c}}'))
+      expect(interpolate('a{{b}}').expression).toEqual('"a"+(b|stringify)');
+      expect(interpolate('{{a}}b').expression).toEqual('(a|stringify)+"b"');
+      expect(interpolate('{{b}}').expression).toEqual('(b|stringify)');
+      expect(interpolate('{{b}}+{{c}}').expression)
           .toEqual('(b|stringify)+"+"+(c|stringify)');
-      expect(interpolate('{{b}}x{{c}}'))
+      expect(interpolate('{{b}}x{{c}}').expression)
           .toEqual('(b|stringify)+"x"+(c|stringify)');
     });
 
+    it('should return expression bindings', (Interpolate interpolate) {
+      expect(interpolate('Hello {{name}}').bindingExpressions).toEqual(['name']);
+      expect(interpolate('a{{b}}C').bindingExpressions)
+          .toEqual(['b']);
+      expect(interpolate('{{b}}x{{c}}').bindingExpressions).toEqual(['b', 'c']);
+    });
+
     it('should Parse Multiline', (Interpolate interpolate) {
-      expect(interpolate("X\nY{{A\n+B}}C\nD"))
+      expect(interpolate("X\nY{{A\n+B}}C\nD").expression)
       .toEqual('"X\nY"+(A\n+B|stringify)+"C\nD"');
     });
 
     it('should escape double quotes', (Interpolate interpolate) {
-      expect(interpolate(r'"{{a}}')).toEqual(r'"\""+(a|stringify)');
-      expect(interpolate(r'\"{{a}}')).toEqual(r'"\\\""+(a|stringify)');
+      expect(interpolate(r'"{{a}}').expression).toEqual(r'"\""+(a|stringify)');
+      expect(interpolate(r'\"{{a}}').expression).toEqual(r'"\\\""+(a|stringify)');
     });
   });
-}
+}