refactor(compiler): pass DirectiveMap on compiler call instead of constructor

Author: pavelgj

lib/bootstrap.dart

@@ -87,7 +87,7 @@ Injector ngBootstrap({
   return zone.run(() {
     var rootElements = [element];
     Injector injector = injectorFactory(ngModules);
-    injector.get(Compiler)(rootElements)(injector, rootElements);
+    injector.get(Compiler)(rootElements, injector.get(DirectiveMap))(injector, rootElements);
     return injector;
   });
 }

lib/core/directive.dart

@@ -436,62 +436,3 @@ abstract class NgDetachAware {
   void detach();
 }
 
-@NgInjectableService()
-class DirectiveMap extends AnnotationsMap<NgAnnotation> {
-  DirectiveMap(Injector injector, MetadataExtractor metadataExtractor,
-      FieldMetadataExtractor fieldMetadataExtractor)
-      : super(injector, metadataExtractor) {
-    Map<NgAnnotation, List<Type>> directives = {};
-    forEach((NgAnnotation annotation, Type type) {
-      var match;
-      var fieldMetadata = fieldMetadataExtractor(type);
-      if (fieldMetadata.isNotEmpty) {
-        var newMap = annotation.map == null ? {} : new Map.from(annotation.map);
-        fieldMetadata.forEach((String fieldName, AttrFieldAnnotation ann) {
-          var attrName = ann.attrName;
-          if (newMap.containsKey(attrName)) {
-            throw 'Mapping for attribute $attrName is already defined (while '
-                  'processing annottation for field $fieldName of $type)';
-          }
-          newMap[attrName] = '${ann.mappingSpec}$fieldName';
-        });
-        annotation = annotation.cloneWithNewMap(newMap);
-      }
-      directives.putIfAbsent(annotation, () => []).add(type);
-    });
-    _map.clear();
-    _map.addAll(directives);
-  }
-}
-
-@NgInjectableService()
-class FieldMetadataExtractor {
-  List<TypeMirror> _fieldAnnotations = [reflectType(NgAttr),
-      reflectType(NgOneWay), reflectType(NgOneWayOneTime),
-      reflectType(NgTwoWay), reflectType(NgCallback)];
-
-  Map<String, AttrFieldAnnotation> call(Type type) {
-    ClassMirror cm = reflectType(type);
-    Map<String, AttrFieldAnnotation> fields = <String, AttrFieldAnnotation>{};
-    cm.declarations.forEach((Symbol name, DeclarationMirror decl) {
-      if (decl is VariableMirror ||
-          (decl is MethodMirror && (decl.isGetter || decl.isSetter))) {
-        var fieldName = MirrorSystem.getName(name);
-        if (decl is MethodMirror && decl.isSetter) {
-          // Remove = from the end of the setter.
-          fieldName = fieldName.substring(0, fieldName.length - 1);
-        }
-        decl.metadata.forEach((InstanceMirror meta) {
-          if (_fieldAnnotations.contains(meta.type)) {
-            if (fields[fieldName] != null) {
-              throw 'Attribute annotation for $fieldName is defined more '
-                    'than once in $type';
-            }
-            fields[fieldName] = meta.reflectee as AttrFieldAnnotation;
-          }
-        });
-      }
-    });
-    return fields;
-  }
-}

lib/core/module.dart

@@ -30,9 +30,7 @@ class NgCoreModule extends Module {
     type(ScopeDigestTTL);
 
     type(MetadataExtractor);
-    type(FieldMetadataExtractor);
     type(Cache);
-    type(DirectiveMap);
     type(ExceptionHandler);
     type(FilterMap);
     type(Interpolate);

lib/core/registry.dart

@@ -31,26 +31,26 @@ abstract class AnnotationMap<K> {
 }
 
 abstract class AnnotationsMap<K> {
-  final Map<K, List<Type>> _map = {};
+  final Map<K, List<Type>> map = {};
 
   AnnotationsMap(Injector injector, MetadataExtractor extractMetadata) {
     injector.types.forEach((type) {
       var meta = extractMetadata(type)
           .where((annotation) => annotation is K)
           .forEach((annotation) {
-            _map.putIfAbsent(annotation, () => []).add(type);
+            map.putIfAbsent(annotation, () => []).add(type);
           });
     });
   }
 
   List operator[](K annotation) {
-    var value = _map[annotation];
+    var value = map[annotation];
     if (value == null) throw 'No $annotation found!';
     return value;
   }
 
   forEach(fn(K, Type)) {
-    _map.forEach((annotation, types) {
+    map.forEach((annotation, types) {
       types.forEach((type) {
         fn(annotation, type);
       });

lib/core_dom/block_factory.dart

@@ -154,11 +154,12 @@ class BlockFactory {
             BlockCache blockCache = injector.get(BlockCache);
             Http http = injector.get(Http);
             TemplateCache templateCache = injector.get(TemplateCache);
+            DirectiveMap directives = injector.get(DirectiveMap);
             // This is a bit of a hack since we are returning different type then we are.
             var componentFactory = new _ComponentFactory(node, ref.type, ref.annotation as NgComponent, injector.get(dom.NodeTreeSanitizer));
             if (fctrs == null) fctrs = new Map<Type, _ComponentFactory>();
             fctrs[ref.type] = componentFactory;
-            return componentFactory.call(injector, compiler, scope, blockCache, http, templateCache);
+            return componentFactory.call(injector, compiler, scope, blockCache, http, templateCache, directives);
           }, visibility: visibility);
         } else {
           nodeModule.type(ref.type, visibility: visibility);
@@ -258,19 +259,20 @@ class BlockCache {
 
   BlockCache(this.$http, this.$templateCache, this.compiler, this.treeSanitizer);
 
-  BlockFactory fromHtml(String html) {
+  BlockFactory fromHtml(String html, DirectiveMap directives) {
     BlockFactory blockFactory = _blockFactoryCache.get(html);
     if (blockFactory == null) {
       var div = new dom.Element.tag('div');
       div.setInnerHtml(html, treeSanitizer: treeSanitizer);
-      blockFactory = compiler(div.nodes);
+      blockFactory = compiler(div.nodes, directives);
       _blockFactoryCache.put(html, blockFactory);
     }
     return blockFactory;
   }
 
-  async.Future<BlockFactory> fromUrl(String url) {
-    return $http.getString(url, cache: $templateCache).then(fromHtml);
+  async.Future<BlockFactory> fromUrl(String url, DirectiveMap directives) {
+    return $http.getString(url, cache: $templateCache).then(
+        (html) => fromHtml(html, directives));
   }
 }
 
@@ -294,7 +296,7 @@ class _ComponentFactory {
 
   _ComponentFactory(this.element, this.type, this.component, this.treeSanitizer);
 
-  dynamic call(Injector injector, Compiler compiler, Scope scope, BlockCache $blockCache, Http $http, TemplateCache $templateCache) {
+  dynamic call(Injector injector, Compiler compiler, Scope scope, BlockCache $blockCache, Http $http, TemplateCache $templateCache, DirectiveMap directives) {
     this.compiler = compiler;
     shadowDom = element.createShadowRoot();
     shadowDom.applyAuthorStyles = component.applyAuthorStyles;
@@ -315,9 +317,9 @@ class _ComponentFactory {
     }
     var blockFuture;
     if (component.template != null) {
-      blockFuture = new async.Future.value($blockCache.fromHtml(component.template));
+      blockFuture = new async.Future.value($blockCache.fromHtml(component.template, directives));
     } else if (component.templateUrl != null) {
-      blockFuture = $blockCache.fromUrl(component.templateUrl);
+      blockFuture = $blockCache.fromUrl(component.templateUrl, directives);
     }
     TemplateLoader templateLoader = new TemplateLoader( async.Future.wait(cssFutures).then((Iterable<String> cssList) {
       if (cssList != null) {

lib/core_dom/compiler.dart

@@ -2,27 +2,23 @@ part of angular.core.dom;
 
 @NgInjectableService()
 class Compiler {
-  final DirectiveMap directives;
   final Profiler _perf;
   final Parser _parser;
   final Expando _expando;
 
-  DirectiveSelector selector;
-
-  Compiler(this.directives, this._perf, this._parser, this._expando) {
-    selector = directiveSelectorFactory(directives);
-  }
+  Compiler(this._perf, this._parser, this._expando);
 
   _compileBlock(NodeCursor domCursor, NodeCursor templateCursor,
-                List<DirectiveRef> useExistingDirectiveRefs) {
+                List<DirectiveRef> useExistingDirectiveRefs,
+                DirectiveMap directives) {
     if (domCursor.nodeList().length == 0) return null;
 
     var directivePositions = null; // don't pre-create to create sparse tree and prevent GC pressure.
     var cursorAlreadyAdvanced;
 
     do {
       var declaredDirectiveRefs = useExistingDirectiveRefs == null
-          ?  selector(domCursor.nodeList()[0])
+          ?  directives.selector(domCursor.nodeList()[0])
           : useExistingDirectiveRefs;
       var children = NgAnnotation.COMPILE_CHILDREN;
       var childDirectivePositions = null;
@@ -44,7 +40,7 @@ class Compiler {
           var remainingDirectives = declaredDirectiveRefs.sublist(j + 1);
           blockFactory = compileTransclusion(
               domCursor, templateCursor,
-              directiveRef, remainingDirectives);
+              directiveRef, remainingDirectives, directives);
 
           j = jj; // stop processing further directives since they belong to transclusion;
         }
@@ -59,7 +55,8 @@ class Compiler {
       if (children == NgAnnotation.COMPILE_CHILDREN && domCursor.descend()) {
         templateCursor.descend();
 
-        childDirectivePositions = _compileBlock(domCursor, templateCursor, null);
+        childDirectivePositions =
+            _compileBlock(domCursor, templateCursor, null, directives);
 
         domCursor.ascend();
         templateCursor.ascend();
@@ -82,14 +79,16 @@ class Compiler {
   BlockFactory compileTransclusion(
                       NodeCursor domCursor, NodeCursor templateCursor,
                       DirectiveRef directiveRef,
-                      List<DirectiveRef> transcludedDirectiveRefs) {
+                      List<DirectiveRef> transcludedDirectiveRefs,
+                      DirectiveMap directives) {
     var anchorName = directiveRef.annotation.selector + (directiveRef.value != null ? '=' + directiveRef.value : '');
     var blockFactory;
     var blocks;
 
     var transcludeCursor = templateCursor.replaceWithAnchor(anchorName);
     var domCursorIndex = domCursor.index;
-    var directivePositions = _compileBlock(domCursor, transcludeCursor, transcludedDirectiveRefs);
+    var directivePositions =
+        _compileBlock(domCursor, transcludeCursor, transcludedDirectiveRefs, directives);
     if (directivePositions == null) directivePositions = [];
 
     blockFactory = new BlockFactory(transcludeCursor.elements, directivePositions, _perf, _expando);
@@ -112,14 +111,14 @@ class Compiler {
     return blockFactory;
   }
 
-  BlockFactory call(List<dom.Node> elements) {
+  BlockFactory call(List<dom.Node> elements, DirectiveMap directives) {
     var timerId;
     assert((timerId = _perf.startTimer('ng.compile', _html(elements))) != false);
     List<dom.Node> domElements = elements;
     List<dom.Node> templateElements = cloneElements(domElements);
     var directivePositions = _compileBlock(
         new NodeCursor(domElements), new NodeCursor(templateElements),
-        null);
+        null, directives);
 
     var blockFactory = new BlockFactory(templateElements,
         directivePositions == null ? [] : directivePositions, _perf, _expando);

lib/core_dom/directive_map.dart

@@ -0,0 +1,65 @@
+part of angular.core.dom;
+
+@NgInjectableService()
+class DirectiveMap extends AnnotationsMap<NgAnnotation> {
+  DirectiveSelector selector;
+
+  DirectiveMap(Injector injector, MetadataExtractor metadataExtractor,
+      FieldMetadataExtractor fieldMetadataExtractor)
+      : super(injector, metadataExtractor) {
+    Map<NgAnnotation, List<Type>> directives = {};
+    forEach((NgAnnotation annotation, Type type) {
+      var match;
+      var fieldMetadata = fieldMetadataExtractor(type);
+      if (fieldMetadata.isNotEmpty) {
+        var newMap = annotation.map == null ? {} : new Map.from(annotation.map);
+        fieldMetadata.forEach((String fieldName, AttrFieldAnnotation ann) {
+          var attrName = ann.attrName;
+          if (newMap.containsKey(attrName)) {
+            throw 'Mapping for attribute $attrName is already defined (while '
+                  'processing annottation for field $fieldName of $type)';
+          }
+          newMap[attrName] = '${ann.mappingSpec}$fieldName';
+        });
+        annotation = annotation.cloneWithNewMap(newMap);
+      }
+      directives.putIfAbsent(annotation, () => []).add(type);
+    });
+    map.clear();
+    map.addAll(directives);
+
+    selector = directiveSelectorFactory(this);
+  }
+}
+
+@NgInjectableService()
+class FieldMetadataExtractor {
+  List<TypeMirror> _fieldAnnotations = [reflectType(NgAttr),
+      reflectType(NgOneWay), reflectType(NgOneWayOneTime),
+      reflectType(NgTwoWay), reflectType(NgCallback)];
+
+  Map<String, AttrFieldAnnotation> call(Type type) {
+    ClassMirror cm = reflectType(type);
+    Map<String, AttrFieldAnnotation> fields = <String, AttrFieldAnnotation>{};
+    cm.declarations.forEach((Symbol name, DeclarationMirror decl) {
+      if (decl is VariableMirror ||
+          (decl is MethodMirror && (decl.isGetter || decl.isSetter))) {
+        var fieldName = MirrorSystem.getName(name);
+        if (decl is MethodMirror && decl.isSetter) {
+          // Remove = from the end of the setter.
+          fieldName = fieldName.substring(0, fieldName.length - 1);
+        }
+        decl.metadata.forEach((InstanceMirror meta) {
+          if (_fieldAnnotations.contains(meta.type)) {
+            if (fields[fieldName] != null) {
+              throw 'Attribute annotation for $fieldName is defined more '
+                    'than once in $type';
+            }
+            fields[fieldName] = meta.reflectee as AttrFieldAnnotation;
+          }
+        });
+      }
+    });
+    return fields;
+  }
+}

lib/core_dom/module.dart

@@ -3,6 +3,7 @@ library angular.core.dom;
 import 'dart:async' as async;
 import 'dart:convert' show JSON;
 import 'dart:html' as dom;
+import 'dart:mirrors';
 
 import 'package:di/di.dart';
 import 'package:perf_api/perf_api.dart';
@@ -17,6 +18,7 @@ part 'cookies.dart';
 part 'common.dart';
 part 'compiler.dart';
 part 'directive.dart';
+part 'directive_map.dart';
 part 'http.dart';
 part 'ng_mustache.dart';
 part 'node_cursor.dart';
@@ -46,6 +48,8 @@ class NgCoreDomModule extends Module {
     type(BrowserCookies);
     type(Cookies);
     type(LocationWrapper);
+    type(FieldMetadataExtractor);
+    type(DirectiveMap);
   }
 }
 

lib/directive/ng_include.dart

@@ -24,11 +24,12 @@ class NgIncludeDirective {
   final Scope scope;
   final BlockCache blockCache;
   final Injector injector;
+  final DirectiveMap directives;
 
   Block _previousBlock;
   Scope _previousScope;
 
-  NgIncludeDirective(this.element, this.scope, this.blockCache, this.injector);
+  NgIncludeDirective(this.element, this.scope, this.blockCache, this.injector, this.directives);
 
   _cleanUp() {
     if (_previousBlock == null) return;
@@ -54,7 +55,7 @@ class NgIncludeDirective {
   set url(value) {
     _cleanUp();
     if (value != null && value != '') {
-      blockCache.fromUrl(value).then(_updateContent);
+      blockCache.fromUrl(value, directives).then(_updateContent);
     }
   }
 }

lib/mock/test_bed.dart

@@ -34,7 +34,7 @@ class TestBed {
    *
    * An option [scope] parameter can be supplied to link it with non root scope.
    */
-  Element compile(html, {Scope scope}) {
+  Element compile(html, {Scope scope, DirectiveMap directives}) {
     var injector = this.injector;
     if(scope != null) {
       injector = injector.createChild([new Module()..value(Scope, scope)]);
@@ -49,7 +49,10 @@ class TestBed {
       throw 'Expecting: String, Node, or List<Node> got $html.';
     }
     rootElement = rootElements[0];
-    rootBlock = compiler(rootElements)(injector, rootElements);
+    if (directives == null) {
+      directives = injector.get(DirectiveMap);
+    }
+    rootBlock = compiler(rootElements, directives)(injector, rootElements);
     return rootElement;
   }