Revert revision 33053

third_party/pkg/angular/lib/core/directive.dart

 part of angular.core;
 
 abstract class NgAnnotation {
   /**
    * CSS selector which will trigger this component/directive.
    * CSS Selectors are limited to a single element and can contain:
    *
    * * `element-name` limit to a given element name.
    * * `.class` limit to an element with a given class.
    * * `[attribute]` limit to an element with a given attribute name.
@@ skipping 98 matching lines @@
    *
    *  * `@title` maps the title DOM attribute to the controller `title`
    *    field. Notice that this maps the content of the attribute, which
    *    means that it can be used with `{{}}` interpolation.
    *
    *  * `<=>currentItem` maps the expression (in this case the `selectedItem`
    *    in the current scope into the `currentItem` in the controller. Notice
    *    that mapping is bi-directional. A change either in field or on
    *    parent scope will result in change to the other.
    *
-   *  * `&onChange` maps the expression into the controller `onChange`
+   *  * `&onChange` maps the expression into tho controllers `onChange`
    *    field. The result of mapping is a callable function which can be
    *    invoked at any time by the controller. The invocation of the
    *    callable function will result in the expression `doSomething()` to
    *    be executed in the parent context.
    */
   final Map<String, String> map;
 
   /**
    * Use the list to specify expression containing attributes which are not
    * included under [map] with '=' or '@' specification.
    */
   final List<String> exportExpressionAttrs;
 
   /**
    * Use the list to specify a expressions which are evaluated dynamically
-   * (ex. via [Scope.eval]) and are otherwise not statically discoverable.
+   * (ex. via [Scope.$eval]) and are otherwise not statically discoverable.
    */
   final List<String> exportExpressions;
 
+  /**
+   * An expression under which the controller instance will be published into.
+   * This allows the expressions in the template to be referring to controller
+   * instance and its properties.
+   */
+  final String publishAs;
+
   const NgAnnotation({
     this.selector,
     this.children: NgAnnotation.COMPILE_CHILDREN,
     this.visibility: NgDirective.LOCAL_VISIBILITY,
+    this.publishAs,
     this.publishTypes: const [],
     this.map: const {},
     this.exportExpressions: const [],
     this.exportExpressionAttrs: const []
   });
 
   toString() => selector;
   get hashCode => selector.hashCode;
   operator==(other) =>
       other is NgAnnotation && this.selector == other.selector;
 
   NgAnnotation cloneWithNewMap(newMap);
 }
 
 
 /**
  * Meta-data marker placed on a class which should act as a controller for the
  * component. Angular components are a light-weight version of web-components.
  * Angular components use shadow-DOM for rendering their templates.
  *
  * Angular components are instantiated using dependency injection, and can
  * ask for any injectable object in their constructor. Components
  * can also ask for other components or directives declared on the DOM element.
  *
- * Components can implement [NgAttachAware], [NgDetachAware],
- * [NgShadowRootAware] and declare these optional methods:
+ * Components can implement [NgAttachAware], [NgDetachAware], [NgShadowRootAware] and
+ * declare these optional methods:
  *
- * * `attach()` - Called on first [Scope.apply()].
+ * * `attach()` - Called on first [Scope.$digest()].
  * * `detach()` - Called on when owning scope is destroyed.
  * * `onShadowRoot(ShadowRoot shadowRoot)` - Called when [ShadowRoot] is loaded.
  */
 class NgComponent extends NgAnnotation {
   /**
    * Inlined HTML template for the component.
    */
   final String template;
 
   /**
    * A URL to HTML template. This will be loaded asynchronously and
    * cached for future component instances.
    */
   final String templateUrl;
 
   /**
+   * A CSS URL to load into the shadow DOM.
+   */
+  final String cssUrl;
+
+  /**
    * A list of CSS URLs to load into the shadow DOM.
    */
-  final _cssUrls;
+  final List<String> cssUrls;
 
-  /**
+  List<String> get allCssUrls {
+    if (cssUrls == null && cssUrl == null) return null;
+    if (cssUrls == null && cssUrl != null) return [cssUrl];
+    if (cssUrls != null && cssUrl == null) return cssUrls;
+    if (cssUrls != null && cssUrl != null) return [cssUrl]..addAll(cssUrls);
+  }
+
+/**
    * Set the shadow root applyAuthorStyles property. See shadow-DOM
    * documentation for further details.
    */
   final bool applyAuthorStyles;
 
   /**
    * Set the shadow root resetStyleInheritance property. See shadow-DOM
    * documentation for further details.
    */
   final bool resetStyleInheritance;
 
-  /**
-   * An expression under which the component's controller instance will be
-   * published into. This allows the expressions in the template to be referring
-   * to controller instance and its properties.
-   */
-  final String publishAs;
-
   const NgComponent({
     this.template,
     this.templateUrl,
-    cssUrl,
+    this.cssUrl,
+    this.cssUrls,
     this.applyAuthorStyles,
     this.resetStyleInheritance,
-    this.publishAs,
+    publishAs,
     map,
     selector,
     visibility,
     publishTypes : const <Type>[],
     exportExpressions,
-    exportExpressionAttrs})
-      : _cssUrls = cssUrl,
-        super(selector: selector,
+    exportExpressionAttrs
+  }) : super(selector: selector,
              children: NgAnnotation.COMPILE_CHILDREN,
              visibility: visibility,
              publishTypes: publishTypes,
+             publishAs: publishAs,
              map: map,
              exportExpressions: exportExpressions,
              exportExpressionAttrs: exportExpressionAttrs);
 
-  List<String> get cssUrls => _cssUrls == null ?
-      const [] :
-      _cssUrls is List ?  _cssUrls : [_cssUrls];
-
   NgAnnotation cloneWithNewMap(newMap) =>
       new NgComponent(
           template: template,
           templateUrl: templateUrl,
-          cssUrl: cssUrls,
+          cssUrl: cssUrl,
+          cssUrls: cssUrls,
           applyAuthorStyles: applyAuthorStyles,
           resetStyleInheritance: resetStyleInheritance,
           publishAs: publishAs,
           map: newMap,
           selector: selector,
           visibility: visibility,
           publishTypes: publishTypes,
           exportExpressions: exportExpressions,
           exportExpressionAttrs: exportExpressionAttrs);
 }
 
 RegExp _ATTR_NAME = new RegExp(r'\[([^\]]+)\]$');
 
 /**
  * Meta-data marker placed on a class which should act as a directive.
  *
  * Angular directives are instantiated using dependency injection, and can
  * ask for any injectable object in their constructor. Directives
  * can also ask for other components or directives declared on the DOM element.
  *
  * Directives can implement [NgAttachAware], [NgDetachAware] and
  * declare these optional methods:
  *
- * * `attach()` - Called on first [Scope.apply()].
+ * * `attach()` - Called on first [Scope.$digest()].
  * * `detach()` - Called on when owning scope is destroyed.
  */
 class NgDirective extends NgAnnotation {
   static const String LOCAL_VISIBILITY = 'local';
   static const String CHILDREN_VISIBILITY = 'children';
   static const String DIRECT_CHILDREN_VISIBILITY = 'direct_children';
 
-  const NgDirective({children: NgAnnotation.COMPILE_CHILDREN,
+  const NgDirective({
+                    children: NgAnnotation.COMPILE_CHILDREN,
+                    publishAs,
                     map,
                     selector,
                     visibility,
                     publishTypes : const <Type>[],
                     exportExpressions,
-                    exportExpressionAttrs}) : super(selector: selector, children: children, visibility: visibility,
-  publishTypes: publishTypes, map: map,
+                    exportExpressionAttrs
+                    }) : super(selector: selector, children: children, visibility: visibility,
+  publishTypes: publishTypes, publishAs: publishAs, map: map,
   exportExpressions: exportExpressions,
   exportExpressionAttrs: exportExpressionAttrs);
 
   NgAnnotation cloneWithNewMap(newMap) =>
       new NgDirective(
           children: children,
+          publishAs: publishAs,
           map: newMap,
           selector: selector,
           visibility: visibility,
           publishTypes: publishTypes,
           exportExpressions: exportExpressions,
           exportExpressionAttrs: exportExpressionAttrs);
 }
 
 /**
  * Meta-data marker placed on a class which should act as a controller for your application.
  *
  * Controllers are essentially [NgDirective]s with few key differences:
  *
  * * Controllers create a new scope at the element.
  * * Controllers should not do any DOM manipulation.
  * * Controllers are meant for application-logic
  *   (rather then DOM monipulation logic which directives are meant for.)
  *
  * Controllers can implement [NgAttachAware], [NgDetachAware] and
  * declare these optional methods:
  *
- * * `attach()` - Called on first [Scope.apply()].
+ * * `attach()` - Called on first [Scope.$digest()].
  * * `detach()` - Called on when owning scope is destroyed.
  */
 class NgController extends NgDirective {
   static const String LOCAL_VISIBILITY = 'local';
   static const String CHILDREN_VISIBILITY = 'children';
   static const String DIRECT_CHILDREN_VISIBILITY = 'direct_children';
 
-  /**
-   * An expression under which the controller instance will be published into.
-   * This allows the expressions in the template to be referring to controller
-   * instance and its properties.
-   */
-  final String publishAs;
-
   const NgController({
                     children: NgAnnotation.COMPILE_CHILDREN,
-                    this.publishAs,
+                    publishAs,
                     map,
                     selector,
                     visibility,
                     publishTypes : const <Type>[],
                     exportExpressions,
                     exportExpressionAttrs
                     }) : super(selector: selector, children: children, visibility: visibility,
-  publishTypes: publishTypes, map: map,
+  publishTypes: publishTypes, publishAs: publishAs, map: map,
   exportExpressions: exportExpressions,
   exportExpressionAttrs: exportExpressionAttrs);
 
   NgAnnotation cloneWithNewMap(newMap) =>
       new NgController(
           children: children,
           publishAs: publishAs,
           map: newMap,
           selector: selector,
           visibility: visibility,
@@ skipping 74 matching lines @@
 }
 
 /**
  * Implementing directives or components [detach] method will be called when
  * the associated scope is destroyed.
  */
 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;
+  }
+}