feat(testability): implement the testability for ProtractorDart

See https://pub.dartlang.org/packages/protractor

Author: chirayuk

lib/angular.dart

@@ -5,7 +5,8 @@ export 'package:angular/application.dart';
 export 'package:angular/core/module.dart';
 export 'package:angular/directive/module.dart';
 export 'package:angular/core/annotation.dart';
-export 'package:angular/introspection.dart';
+export 'package:angular/introspection.dart' hide
+    elementExpando, publishToJavaScript;
 export 'package:angular/formatter/module.dart';
 export 'package:angular/routing/module.dart';
 export 'package:di/di.dart' hide lastKeyId;

lib/application.dart

@@ -81,7 +81,7 @@ import 'package:angular/core_dom/module_internal.dart';
 import 'package:angular/directive/module.dart';
 import 'package:angular/formatter/module_internal.dart';
 import 'package:angular/routing/module.dart';
-import 'package:angular/introspection_js.dart';
+import 'package:angular/introspection.dart';
 
 import 'package:angular/core_dom/static_keys.dart';
 

lib/core_dom/element_binder.dart

@@ -237,9 +237,8 @@ class ElementBinder {
   void _createDirectiveFactories(DirectiveRef ref, nodeModule, node, nodesAttrsDirectives, nodeAttrs,
                                  visibility) {
     if (ref.type == TextMustache) {
-      nodeModule.bind(TextMustache, toFactory: (Injector injector) {
-        return new TextMustache(node, ref.valueAST, injector.getByKey(SCOPE_KEY));
-      });
+      nodeModule.bind(TextMustache, toFactory: (Injector injector) => new TextMustache(
+              node, ref.valueAST, injector.getByKey(SCOPE_KEY)));
     } else if (ref.type == AttrMustache) {
       if (nodesAttrsDirectives.isEmpty) {
         nodeModule.bind(AttrMustache, toFactory: (Injector injector) {
@@ -310,6 +309,11 @@ class ElementBinder {
       probe = _expando[node] =
           new ElementProbe(parentInjector.getByKey(ELEMENT_PROBE_KEY),
                            node, nodeInjector, scope);
+      directiveRefs.forEach((DirectiveRef ref) {
+        if (ref.valueAST != null) {
+          probe.bindingExpressions.add(ref.valueAST.expression);
+        }
+      });
       scope.on(ScopeEvent.DESTROY).listen((_) {
         _expando[node] = null;
       });

lib/core_dom/mustache.dart

@@ -26,9 +26,9 @@ class AttrMustache {
 
   // This Directive is special and does not go through injection.
   AttrMustache(this._attrs,
-                          String this._attrName,
-                          AST valueAST,
-                          Scope scope) {
+               String this._attrName,
+               AST valueAST,
+               Scope scope) {
     _updateMarkup('', 'INITIAL-VALUE');
 
     _attrs.listenObserverChanges(_attrName, (hasObservers) {

lib/core_dom/view_factory.dart

@@ -193,6 +193,8 @@ class ElementProbe {
   final Injector injector;
   final Scope scope;
   final directives = [];
+  final bindingExpressions = <String>[];
+  final modelExpressions = <String>[];
 
   ElementProbe(this.parent, this.element, this.injector, this.scope);
 }

lib/directive/ng_bind.dart

@@ -20,7 +20,12 @@ part of angular.directive;
 class NgBind {
   final dom.Element element;
 
-  NgBind(this.element);
+  NgBind(this.element, ElementProbe probe) {
+    // TODO(chirayu): Generalize this.
+    if (probe != null) {
+      probe.bindingExpressions.add(element.attributes['ng-bind']);
+    }
+  }
 
   set value(value) => element.text = value == null ? '' : value.toString();
 }

lib/directive/ng_model.dart

@@ -45,10 +45,13 @@ class NgModel extends NgControl implements AttachAware {
   bool _watchCollection;
 
   NgModel(this._scope, NgElement element, Injector injector, NodeAttrs attrs,
-          Animate animate)
+          Animate animate, ElementProbe probe)
       : super(element, injector, animate)
   {
     _expression = attrs["ng-model"];
+    if (probe != null) {
+      probe.modelExpressions.add(_expression);
+    }
     watchCollection = false;
 
     //Since the user will never be editing the value of a select element then

lib/introspection.dart

@@ -3,11 +3,60 @@
 */
 library angular.introspection;
 
+import 'dart:async' as async;
 import 'dart:html' as dom;
+import 'dart:js' as js;
 import 'package:di/di.dart';
-import 'package:angular/introspection_js.dart';
+import 'package:angular/animate/module.dart';
 import 'package:angular/core/module_internal.dart';
 import 'package:angular/core_dom/module_internal.dart';
+import 'package:angular/core/static_keys.dart';
+
+
+/**
+ * A global write only variable which keeps track of objects attached to the
+ * elements. This is useful for debugging AngularDart application from the
+ * browser's REPL.
+ */
+var elementExpando = new Expando('element');
+
+
+ElementProbe _findProbeWalkingUp(dom.Node node, [dom.Node ascendUntil]) {
+  while (node != null && node != ascendUntil) {
+    var probe = elementExpando[node];
+    if (probe != null) return probe;
+    node = node.parent;
+  }
+  return null;
+}
+
+
+_walkProbesInTree(dom.Node node, Function walker) {
+  var probe = elementExpando[node];
+  if (probe == null || walker(probe) != true) {
+    for (var child in node.childNodes) {
+      _walkProbesInTree(child, walker);
+    }
+  }
+}
+
+
+ElementProbe _findProbeInTree(dom.Node node, [dom.Node ascendUntil]) {
+  var probe;
+  _walkProbesInTree(node, (_probe) {
+    probe = _probe;
+    return true;
+  });
+  return (probe != null) ? probe : _findProbeWalkingUp(node, ascendUntil);
+}
+
+
+List<ElementProbe> _findAllProbesInTree(dom.Node node) {
+  List<ElementProbe> probes = [];
+  _walkProbesInTree(node, probes.add);
+  return probes;
+}
+
 
 /**
  * Return the [ElementProbe] object for the closest [Element] in the hierarchy.
@@ -21,25 +70,21 @@ import 'package:angular/core_dom/module_internal.dart';
  * function is not intended to be called from Angular application.
  */
 ElementProbe ngProbe(nodeOrSelector) {
-  var errorMsg;
-  var node;
   if (nodeOrSelector == null) throw "ngProbe called without node";
+  var node = nodeOrSelector;
   if (nodeOrSelector is String) {
     var nodes = ngQuery(dom.document, nodeOrSelector);
-    if (nodes.isNotEmpty) node = nodes.first;
-    errorMsg = "Could not find a probe for the selector '$nodeOrSelector' nor its parents";
-  } else {
-    node = nodeOrSelector;
-    errorMsg = "Could not find a probe for the node '$node' nor its parents";
+    node = (nodes.isNotEmpty) ? nodes.first : null;
   }
-  while (node != null) {
-    var probe = elementExpando[node];
-    if (probe != null) return probe;
-    node = node.parent;
+  var probe = _findProbeWalkingUp(node);
+  if (probe != null) {
+    return probe;
   }
-  throw errorMsg;
+  var forWhat = (nodeOrSelector is String) ? "selector" : "node";
+  throw "Could not find a probe for the $forWhat '$nodeOrSelector' nor its parents";
 }
 
+
 /**
  * Return the [Injector] associated with a current [Element].
  *
@@ -79,6 +124,7 @@ List<dom.Element> ngQuery(dom.Node element, String selector,
   return list;
 }
 
+
 /**
  * Return a List of directives associated with a current [Element].
  *
@@ -88,3 +134,160 @@ List<dom.Element> ngQuery(dom.Node element, String selector,
  */
 List<Object> ngDirectives(nodeOrSelector) => ngProbe(nodeOrSelector).directives;
 
+
+
+js.JsObject _jsProbe(ElementProbe probe) {
+  return new js.JsObject.jsify({
+      "element": probe.element,
+      "injector": _jsInjector(probe.injector),
+      "scope": _jsScopeFromProbe(probe),
+      "directives": probe.directives.map((directive) => _jsDirective(directive)),
+      "bindings": probe.bindingExpressions,
+      "models": probe.modelExpressions
+  })..['_dart_'] = probe;
+}
+
+
+js.JsObject _jsInjector(Injector injector) =>
+    new js.JsObject.jsify({"get": injector.get})..['_dart_'] = injector;
+
+
+js.JsObject _jsScopeFromProbe(ElementProbe probe) =>
+    _jsScope(probe.scope, probe.injector.getByKey(SCOPE_STATS_CONFIG_KEY));
+
+
+js.JsObject _jsScope(Scope scope, ScopeStatsConfig config) {
+  return new js.JsObject.jsify({
+      "apply": scope.apply,
+      "broadcast": scope.broadcast,
+      "context": scope.context,
+      "destroy": scope.destroy,
+      "digest": scope.rootScope.digest,
+      "emit": scope.emit,
+      "flush": scope.rootScope.flush,
+      "get": (name) => scope.context[name],
+      "isAttached": scope.isAttached,
+      "isDestroyed": scope.isDestroyed,
+      "set": (name, value) => scope.context[name] = value,
+      "scopeStatsEnable": () => config.emit = true,
+      "scopeStatsDisable": () => config.emit = false,
+      r"$eval": (expr) => _jsify(scope.eval(expr)),
+  })..['_dart_'] = scope;
+}
+
+
+// Helper function to JSify the result of a scope.eval() for simple cases.
+_jsify(var obj) {
+  if (obj is js.JsObject) {
+    return obj;
+  } else if (obj is Iterable) {
+    return new js.JsObject.jsify(obj)..['_dart_'] = obj;
+  } else {
+    return obj;
+  }
+}
+
+
+_jsDirective(directive) => directive;
+
+
+abstract class _JsObjectProxyable {
+  js.JsObject _toJsObject();
+}
+
+
+typedef List<String> _GetExpressionsFromProbe(ElementProbe probe);
+
+
+/**
+ * Returns the "$testability service" object for JS / Protractor use.
+ *
+ * JS code expects to get a hold of this object in the following way:
+ *
+ *   // Prereq: There is an "angular" object on window accessible via JS.
+ *   var testability = angular.element(document).injector().get('$testability');
+ */
+class _Testability implements _JsObjectProxyable {
+  final dom.Node node;
+  final ElementProbe probe;
+
+  _Testability(this.node, this.probe);
+  _Testability.fromNode(dom.Node node): this(node, _findProbeInTree(node));
+
+  notifyWhenNoOutstandingRequests(callback) {
+    probe.injector.get(VmTurnZone).run(
+        () => new async.Timer(Duration.ZERO, callback));
+  }
+
+  /**
+   * 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].
+   */
+  List<dom.Node> findModels(String modelString, [bool exactMatch]) => _findByExpression(
+      modelString, exactMatch, (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].
+   */
+  List<dom.Node> findBindings(String bindingString, [bool exactMatch]) => _findByExpression(
+      bindingString, exactMatch, (ElementProbe probe) => probe.bindingExpressions);
+
+  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);
+        }
+      }
+    }
+    return results;
+  }
+
+  allowAnimations(bool allowed) {
+    Animate animate = probe.injector.get(Animate);
+    bool previous = animate.animationsAllowed;
+    animate.animationsAllowed = (allowed == true);
+    return previous;
+  }
+
+  js.JsObject _toJsObject() {
+    return new js.JsObject.jsify({
+        'allowAnimations': allowAnimations,
+        'findBindings': (bindingString, [exactMatch]) =>
+            findBindings(bindingString, exactMatch),
+        'findModels': (modelExpressions, [exactMatch]) =>
+            findModels(modelExpressions, exactMatch),
+        'notifyWhenNoOutstandingRequests': (callback) =>
+            notifyWhenNoOutstandingRequests(() => callback.apply([])),
+        'probe': () => _jsProbe(probe),
+        'scope': () => _jsScopeFromProbe(probe),
+        'eval': (expr) => probe.scope.eval(expr),
+        'query': (String selector, [String containsText]) =>
+            ngQuery(node, selector, containsText),
+    })..['_dart_'] = this;
+  }
+}
+
+
+void publishToJavaScript() {
+  var C = js.context;
+  C['ngProbe'] = (nodeOrSelector) => _jsProbe(ngProbe(nodeOrSelector));
+  C['ngInjector'] = (nodeOrSelector) => _jsInjector(ngInjector(nodeOrSelector));
+  C['ngScope'] = (nodeOrSelector) => _jsScopeFromProbe(ngProbe(nodeOrSelector));
+  C['ngQuery'] = (dom.Node node, String selector, [String containsText]) =>
+      new js.JsArray.from(ngQuery(node, selector, containsText));
+  C['angular'] = new js.JsObject.jsify({
+        'resumeBootstrap': ([arg]) {},
+        'getTestability': (node) => new _Testability.fromNode(node)._toJsObject(),
+  });
+}