update to polymer js 0.5.1

pkg/polymer/lib/src/declaration.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of polymer;
 
 /// *Warning* this class is experimental and subject to change.
 ///
 /// The data associated with a polymer-element declaration, if it is backed
 /// by a Dart class instead of a JavaScript prototype.
@@ skipping 61 matching lines @@
   // TODO(sigmund): investigate whether we need more than 1 set of local events
   // per element (why does the js implementation stores 1 per template node?)
   Expando<Set<String>> _templateDelegates;
 
   String get extendee => superDeclaration != null ?
       superDeclaration.name : null;
 
   /// The root URI for assets.
   Uri _rootUri;
 
+  /// List of properties to ignore for observation.
+  static Set<Symbol> _OBSERVATION_BLACKLIST =
+      new HashSet.from(const [#attribute]);
+
+  static bool _canObserveProperty(Symbol property) =>
+      !_OBSERVATION_BLACKLIST.contains(property);
+
+  /// This list contains some property names that people commonly want to use,
+  /// but won't work because of Chrome/Safari bugs. It isn't an exhaustive
+  /// list. In particular it doesn't contain any property names found on
+  /// subtypes of HTMLElement (e.g. name, value). Rather it attempts to catch
+  /// some common cases.
+  ///
+  /// Dart Note: `class` is left out since its an invalid symbol in dart. This
+  /// means that nobody could make a property by this name anyways though.
+  /// Dart Note: We have added `classes` to this list, which is the dart:html
+  /// equivalent of `classList` but more likely to have conflicts.
+  static Set<Symbol> _PROPERTY_NAME_BLACKLIST = new HashSet.from([
+      const Symbol('children'), const Symbol('id'), const Symbol('hidden'),
+      const Symbol('style'), const Symbol('title'), const Symbol('classes')]);
+
+  bool _checkPropertyBlacklist(Symbol name) {
+    if (_PROPERTY_NAME_BLACKLIST.contains(name)) {
+      print('Cannot define property "$name" for element "${this.name}" '
+          'because it has the same name as an HTMLElement property, and not '
+          'all browsers support overriding that. Consider giving it a '
+          'different name. ');
+      return true;
+    }
+    return false;
+  }
+
   // Dart note: since polymer-element is handled in JS now, we have a simplified
   // flow for registering. We don't need to wait for the supertype or the code
   // to be noticed.
   PolymerDeclaration(this.element, this.name, this.type, this.superDeclaration);
 
   void register() {
     // more declarative features
     desugar();
     // register our custom element
     registerType(name);
@@ skipping 149 matching lines @@
     // NOTE: the following is not possible in Dart; fields must be declared.
     // install 'attributes' as properties on the prototype,
     // but don't override
   }
 
   void _getPublishedProperties(Type type) {
     var options = const smoke.QueryOptions(includeInherited: true,
         includeUpTo: HtmlElement, withAnnotations: const [PublishedProperty]);
     for (var decl in smoke.query(type, options)) {
       if (decl.isFinal) continue;
+      if (_checkPropertyBlacklist(decl.name)) continue;
       if (_publish == null) _publish = {};
       _publish[new PropertyPath([decl.name])] = decl;
 
       // Should we reflect the property value to the attribute automatically?
       if (decl.annotations
           .where((a) => a is PublishedProperty)
           .any((a) => a.reflect)) {
 
         if (_reflect == null) _reflect = new Set();
         _reflect.add(smoke.symbolToName(decl.name));
@@ skipping 155 matching lines @@
 
   /// Fetch a list of all *Changed methods so we can observe the associated
   /// properties.
   void inferObservers() {
     for (var decl in smoke.query(type, _changedMethodQueryOptions)) {
       // TODO(jmesserly): now that we have a better system, should we
       // deprecate *Changed methods?
       if (_observe == null) _observe = new HashMap();
       var name = smoke.symbolToName(decl.name);
       name = name.substring(0, name.length - 7);
+      if (!_canObserveProperty(decl.name)) continue;
       _observe[new PropertyPath(name)] = [decl.name];
     }
   }
 
   /// Fetch a list of all methods annotated with [ObserveProperty] so we can
   /// observe the associated properties.
   void explodeObservers() {
     var options = const smoke.QueryOptions(includeFields: false,
         includeProperties: false, includeMethods: true, includeInherited: true,
         includeUpTo: HtmlElement, withAnnotations: const [ObserveProperty]);
@@ skipping 27 matching lines @@
     // Here we just extract the information from annotations and store it as
     // properties on the declaration.
 
     // Dart Note: The js side makes computed properties read only, and does
     // special logic right here for them. For us they are automatically read
     // only unless you define a setter for them, so we left that out.
     var options = const smoke.QueryOptions(includeInherited: true,
         includeUpTo: HtmlElement, withAnnotations: const [ComputedProperty]);
     var existing = {};
     for (var decl in smoke.query(type, options)) {
+      var name = decl.name;
+      if (_checkPropertyBlacklist(name)) continue;
       var meta = decl.annotations.firstWhere((e) => e is ComputedProperty);
-      var name = decl.name;
       var prev = existing[name];
       // The definition of a child class takes priority.
       if (prev == null || smoke.isSubclassOf(decl.type, prev.type)) {
         _computed[name] = meta.expression;
         existing[name] = decl;
       }
     }
   }
 }
 
 /// maps tag names to prototypes
 final Map _typesByName = new Map<String, Type>();
 
 Type _getRegisteredType(String name) => _typesByName[name];
 
 /// Dart Note: instanceOfType not implemented for dart, its not needed.
 
 /// track document.register'ed tag names and their declarations
 final Map _declarations = new Map<String, PolymerDeclaration>();
 
 bool _isRegistered(String name) => _declarations.containsKey(name);
 PolymerDeclaration _getDeclaration(String name) => _declarations[name];
 
-/// Using Polymer's platform/src/ShadowCSS.js passing the style tag's content.
+/// Using Polymer's web_components/src/ShadowCSS.js passing the style tag's
+/// content.
 void _shimShadowDomStyling(DocumentFragment template, String name,
     String extendee) {
   if (_ShadowCss == null ||!_hasShadowDomPolyfill) return;
 
   _ShadowCss.callMethod('shimStyling', [template, name, extendee]);
 }
 
 final bool _hasShadowDomPolyfill = js.context.hasProperty('ShadowDOMPolyfill');
-final JsObject _ShadowCss = _Platform != null ? _Platform['ShadowCSS'] : null;
+final JsObject _ShadowCss =
+    _WebComponents != null ? _WebComponents['ShadowCSS'] : null;
 
 const _STYLE_SELECTOR = 'style';
 const _SHEET_SELECTOR = 'link[rel=stylesheet]';
 const _STYLE_GLOBAL_SCOPE = 'global';
 const _SCOPE_ATTR = 'polymer-scope';
 const _STYLE_SCOPE_ATTRIBUTE = 'element';
 const _STYLE_CONTROLLER_SCOPE = 'controller';
 
 String _cssTextFromSheet(LinkElement sheet) {
   if (sheet == null) return '';
@@ skipping 33 matching lines @@
 
 bool _isObserverMethod(Symbol symbol) {
   String name = smoke.symbolToName(symbol);
   if (name == null) return false;
   return name.endsWith('Changed') && name != 'attributeChanged';
 }
 
 
 final _ATTRIBUTES_REGEX = new RegExp(r'\s|,');
 
-final JsObject _Platform = js.context['Platform'];
+final JsObject _WebComponents = js.context['WebComponents'];
 final JsObject _Polymer = js.context['Polymer'];