feat(Template): @template replaces @decorator(Directive.TRANSCLUDE_CHILDREN)

1- Transclusion syntax has changed:

Before:

    @decorator(
        selector: '[ng-if]',
        children: Directive.TRANSCLUDE_CHILDREN,
        map: const {'.': 'mapping'},
        <other kv pairs>)

After:

    @template(
        selector: '[ng-if]',
        map: const {'ng-if' : 'mapping'},
        <other kv pairs>)

2- Directive.children has been removed in favor of
Directive.compileChildren

Before:

    children: Directive.COMPILE_CHILDREN
    children: Directive.IGNORE_CHILDREN
    children: Directive.TRANSCLUDE_CHILDREN

After:

    compileChildren: true
    compileChildren: false
    Use @template (see the previous section)

Closes #1003

Author: vicb

lib/application_factory.dart

@@ -51,6 +51,7 @@ import 'dart:html';
 metaTargets: const [
     Injectable,
     Decorator,
+    Template,
     Controller,
     Component,
     Formatter

lib/core/annotation.dart

@@ -17,6 +17,7 @@ export "package:angular/core/annotation_src.dart" show
     Component,
     Controller,
     Decorator,
+    Template,
 
     DirectiveAnnotation,
     NgAttr,

lib/core/annotation_src.dart

@@ -68,30 +68,11 @@ abstract class Directive {
    * Specifies the compiler action to be taken on the child nodes of the
    * element which this currently being compiled.  The values are:
    *
-   * * [COMPILE_CHILDREN] (*default*)
-   * * [TRANSCLUDE_CHILDREN]
-   * * [IGNORE_CHILDREN]
+   * * [:true:] Compile the child nodes of the element. (default)
+   * * [:false:] Do not compile/visit the child nodes.  Angular markup on
+   *   descendant nodes will not be processed.
    */
-  @deprecated
-  final String children;
-
-  /**
-   * Compile the child nodes of the element.  This is the default.
-   */
-  @deprecated
-  static const String COMPILE_CHILDREN = 'compile';
-  /**
-   * Compile the child nodes for transclusion and makes available
-   * [BoundViewFactory], [ViewFactory] and [ViewPort] for injection.
-   */
-  @deprecated
-  static const String TRANSCLUDE_CHILDREN = 'transclude';
-  /**
-   * Do not compile/visit the child nodes.  Angular markup on descendant nodes
-   * will not be processed.
-   */
-  @deprecated
-  static const String IGNORE_CHILDREN = 'ignore';
+   final bool compileChildren;
 
   /**
    * A directive/component controller class can be injected into other
@@ -214,18 +195,19 @@ abstract class Directive {
 
   const Directive({
     this.selector,
-    this.children: Directive.COMPILE_CHILDREN,
+    this.compileChildren: true,
     this.visibility: Directive.LOCAL_VISIBILITY,
     this.module,
     this.map: const {},
     this.exportExpressions: const [],
     this.exportExpressionAttrs: const []
   });
 
-  toString() => selector;
-  get hashCode => selector.hashCode;
-  operator==(other) =>
-      other is Directive && selector == other.selector;
+  String toString() => selector;
+
+  int get hashCode => selector.hashCode;
+
+  bool operator==(other) => other is Directive && selector == other.selector;
 
   Directive _cloneWithNewMap(newMap);
 }
@@ -332,7 +314,7 @@ class Component extends Directive {
         _applyAuthorStyles = applyAuthorStyles,
         _resetStyleInheritance = resetStyleInheritance,
         super(selector: selector,
-             children: Directive.COMPILE_CHILDREN,
+             compileChildren: true,
              visibility: visibility,
              map: map,
              module: module,
@@ -343,7 +325,7 @@ class Component extends Directive {
       const [] :
       _cssUrls is List ?  _cssUrls : [_cssUrls];
 
-  Directive _cloneWithNewMap(newMap) =>
+  Component _cloneWithNewMap(newMap) =>
       new Component(
           template: template,
           templateUrl: templateUrl,
@@ -374,24 +356,24 @@ class Component extends Directive {
  * * `detach()` - Called on when owning scope is destroyed.
  */
 class Decorator extends Directive {
-  const Decorator({children: Directive.COMPILE_CHILDREN,
+  const Decorator({compileChildren: true,
                     map,
                     selector,
                     module,
                     visibility,
                     exportExpressions,
                     exportExpressionAttrs})
       : super(selector: selector,
-              children: children,
+              compileChildren: compileChildren,
               visibility: visibility,
               map: map,
               module: module,
               exportExpressions: exportExpressions,
               exportExpressionAttrs: exportExpressionAttrs);
 
-  Directive _cloneWithNewMap(newMap) =>
+  Decorator _cloneWithNewMap(newMap) =>
       new Decorator(
-          children: children,
+          compileChildren: compileChildren,
           map: newMap,
           module: module,
           selector: selector,
@@ -400,6 +382,45 @@ class Decorator extends Directive {
           exportExpressionAttrs: exportExpressionAttrs);
 }
 
+
+
+/**
+* Meta-data marker placed on a class which should act as template.
+*
+* Angular templates are instantiated using dependency injection, and can
+* ask for any injectable object in their constructor. Templates can also ask
+* for other components or directives declared on the DOM element.
+*
+* Templates can implement [NgAttachAware], [NgDetachAware] and declare these
+* optional methods:
+*
+* * `attach()` - Called on first [Scope.apply()].
+* * `detach()` - Called on when owning scope is destroyed.
+*/
+class Template extends Directive {
+  const Template({map,
+                  selector,
+                  module,
+                  visibility,
+                  exportExpressions,
+                  exportExpressionAttrs})
+      : super(selector: selector,
+              compileChildren: true,
+              visibility: visibility,
+              map: map,
+              module: module,
+              exportExpressions: exportExpressions,
+              exportExpressionAttrs: exportExpressionAttrs);
+
+  Template _cloneWithNewMap(newMap) =>
+      new Template(map: newMap,
+                   module: module,
+                   selector: selector,
+                   visibility: visibility,
+                   exportExpressions: exportExpressions,
+                   exportExpressionAttrs: exportExpressionAttrs);
+}
+
 /**
  * Meta-data marker placed on a class which should act as a controller for your
  * application.
@@ -427,7 +448,7 @@ class Controller extends Decorator {
   final String publishAs;
 
   const Controller({
-                    children: Directive.COMPILE_CHILDREN,
+                    compileChildren: true,
                     this.publishAs,
                     map,
                     module,
@@ -437,7 +458,7 @@ class Controller extends Decorator {
                     exportExpressionAttrs
                     })
       : super(selector: selector,
-              children: children,
+              compileChildren: compileChildren,
               visibility: visibility,
               map: map,
               module: module,
@@ -446,7 +467,7 @@ class Controller extends Decorator {
 
   Directive _cloneWithNewMap(newMap) =>
       new Controller(
-          children: children,
+          compileChildren: compileChildren,
           publishAs: publishAs,
           module: module,
           map: newMap,

lib/core/registry_dynamic.dart

@@ -7,9 +7,9 @@ import 'package:angular/core/registry.dart';
 export 'package:angular/core/registry.dart' show
     MetadataExtractor;
 
-var _fieldMetadataCache = new Map<Type, Map<String, DirectiveAnnotation>>();
-
 class DynamicMetadataExtractor implements MetadataExtractor {
+  static final _fieldMetadataCache = <Type, Map<String, DirectiveAnnotation>>{};
+
   final _fieldAnnotations = [
         reflectType(NgAttr),
         reflectType(NgOneWay),
@@ -24,29 +24,28 @@ class DynamicMetadataExtractor implements MetadataExtractor {
     if (metadata == null) {
       metadata = [];
     } else {
-      metadata =  metadata.map((InstanceMirror im) => map(type, im.reflectee));
+      metadata =  metadata.map((InstanceMirror im) => _mergeMap(type, im.reflectee));
     }
     return metadata;
   }
 
-  map(Type type, obj) {
-    if (obj is Directive) {
-      return mapDirectiveAnnotation(type, obj);
-    } else {
-      return obj;
-    }
-  }
-
-  Directive mapDirectiveAnnotation(Type type, Directive annotation) {
-    var match;
-    var fieldMetadata = fieldMetadataExtractor(type);
-    if (fieldMetadata.isNotEmpty) {
-      var newMap = annotation.map == null ? {} : new Map.from(annotation.map);
-      fieldMetadata.forEach((String fieldName, DirectiveAnnotation ann) {
+ /**
+  * Merges the field annotations with the [AbstractNgAttrAnnotation.map]
+  * definition from the [Directive].
+  *
+  * [_mergeDirectiveMap] throws when the definition for an annotated is
+  * duplicated in the [AbstractNgAttrAnnotation.map]
+  */
+ dynamic _mergeMap(Type type, annotation) {
+   if (annotation is! Directive) return annotation;
+    var metaData = _extractFieldMetadata(type);
+    if (metaData.isNotEmpty) {
+      var newMap = annotation.map == null ? <String, String>{} : new Map.from(annotation.map);
+      metaData.forEach((String fieldName, DirectiveAnnotation 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)';
+                'processing annotation for field $fieldName of $type)';
         }
         newMap[attrName] = '${mappingSpec(ann)}$fieldName';
       });
@@ -55,21 +54,17 @@ class DynamicMetadataExtractor implements MetadataExtractor {
     return annotation;
   }
 
-
-  Map<String, DirectiveAnnotation> fieldMetadataExtractor(Type type) =>
+  Map<String, DirectiveAnnotation> _extractFieldMetadata(Type type) =>
       _fieldMetadataCache.putIfAbsent(type, () => _fieldMetadataExtractor(reflectType(type)));
 
+  /// Extract metadata defined on fields via a [DirectiveAnnotation]
   Map<String, DirectiveAnnotation> _fieldMetadataExtractor(ClassMirror cm) {
     var fields = <String, DirectiveAnnotation>{};
-    if(cm.superclass != null) {
-      fields.addAll(_fieldMetadataExtractor(cm.superclass));
-    } else {
-      fields = {};
-    }
+    if(cm.superclass != null) fields.addAll(_fieldMetadataExtractor(cm.superclass));
+
     Map<Symbol, DeclarationMirror> declarations = cm.declarations;
-    declarations.forEach((symbol, dm) {
-      if(dm is VariableMirror ||
-          dm is MethodMirror && (dm.isGetter || dm.isSetter)) {
+    declarations.forEach((Symbol symbol, DeclarationMirror dm) {
+      if (dm is VariableMirror || dm is MethodMirror && (dm.isGetter || dm.isSetter)) {
         var fieldName = MirrorSystem.getName(symbol);
         if (dm is MethodMirror && dm.isSetter) {
           // Remove "=" from the end of the setter.
@@ -79,7 +74,7 @@ class DynamicMetadataExtractor implements MetadataExtractor {
           if (_fieldAnnotations.contains(meta.type)) {
             if (fields.containsKey(fieldName)) {
               throw 'Attribute annotation for $fieldName is defined more '
-                'than once in ${cm.reflectedType}';
+                    'than once in ${cm.reflectedType}';
             }
             fields[fieldName] = meta.reflectee as DirectiveAnnotation;
           }

lib/core_dom/common.dart

@@ -18,8 +18,18 @@ class DirectiveRef {
   final Directive annotation;
   final String value;
   final mappings = new List<MappingParts>();
-
-  DirectiveRef(this.element, this.type, this.annotation, [ this.value ]);
+  Map<String, String> _templateAttrs;
+  Map<String, String> get templateAttrs => _templateAttrs;
+
+  DirectiveRef(this.element, this.type, this.annotation, [ this.value ]) {
+    if (annotation is Template && annotation.map != null) {
+      var attributes = (element as dom.Element).attributes;
+      _templateAttrs = <String, String>{};
+      annotation.map.keys.forEach((attrName) {
+        _templateAttrs[attrName] = attributes[attrName];
+      });
+    }
+  }
 
   String toString() {
     var html = element is dom.Element