Upgrade to 1.0 and switch clients to dom-repeat where needed.

third_party/polymer/v0_8/components/polymer/polymer-micro.html

Index: third_party/polymer/v0_8/components/polymer/polymer-micro.html
diff --git a/third_party/polymer/v0_8/components/polymer/polymer-micro.html b/third_party/polymer/v0_8/components/polymer/polymer-micro.html
index 8cf5d389b32b7c766a4135ed4e522373696013ce..1dd612383936db8fa143ab17f2d27bdea121aeb4 100644
--- a/third_party/polymer/v0_8/components/polymer/polymer-micro.html
+++ b/third_party/polymer/v0_8/components/polymer/polymer-micro.html
@@ -6,46 +6,539 @@ The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
 The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
 Code distributed by Google as part of the polymer project is also
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
--->
-<link rel="import" href="src/polymer-lib.html">
-<link rel="import" href="src/micro/tag.html">
-<link rel="import" href="src/micro/behaviors.html">
-<link rel="import" href="src/micro/extends.html">
-<link rel="import" href="src/micro/constructor.html">
-<link rel="import" href="src/micro/properties.html">
-<link rel="import" href="src/micro/attributes.html">
-<link rel="import" href="src/micro/debouncer.html">
-
-<script>
-
-  Polymer.Base._addFeature({
-
-    _registerFeatures: function() {
-      // identity
-      this._prepIs();
-      // shared behaviors
-      this._prepBehaviors();
-      // inheritance
-      this._prepExtends();
-      // factory
-      this._prepConstructor();
-    },
-
-    _prepBehavior: function() {},
-
-    _initFeatures: function() {
-      // setup debouncers
-      this._setupDebouncers();
-      // acquire behaviors
-      this._marshalBehaviors();
-    },
-
-    _marshalBehavior: function(b) {
-      // publish attributes to instance
-      this._installHostAttributes(b.hostAttributes);
-    }
-
-  });
-
-</script>
+--><script>(function() {
+function resolve() {
+document.body.removeAttribute("unresolved");
+}
+if (window.WebComponents) {
+addEventListener("WebComponentsReady", resolve);
+} else {
+resolve();
+}
+})();
+
+Polymer = {
+Settings: function() {
+var user = window.Polymer || {};
+location.search.slice(1).split("&").forEach(function(o) {
+o = o.split("=");
+o[0] && (user[o[0]] = o[1] || true);
+});
+var wantShadow = user.dom === "shadow";
+var hasShadow = Boolean(Element.prototype.createShadowRoot);
+var nativeShadow = hasShadow && !window.ShadowDOMPolyfill;
+var useShadow = wantShadow && hasShadow;
+var hasNativeImports = Boolean("import" in document.createElement("link"));
+var useNativeImports = hasNativeImports;
+var useNativeCustomElements = !window.CustomElements || window.CustomElements.useNative;
+return {
+wantShadow: wantShadow,
+hasShadow: hasShadow,
+nativeShadow: nativeShadow,
+useShadow: useShadow,
+useNativeShadow: useShadow && nativeShadow,
+useNativeImports: useNativeImports,
+useNativeCustomElements: useNativeCustomElements
+};
+}()
+};
+
+(function() {
+var userPolymer = window.Polymer;
+window.Polymer = function(prototype) {
+var ctor = desugar(prototype);
+prototype = ctor.prototype;
+var options = {
+prototype: prototype
+};
+if (prototype.extends) {
+options.extends = prototype.extends;
+}
+Polymer.telemetry._registrate(prototype);
+document.registerElement(prototype.is, options);
+return ctor;
+};
+var desugar = function(prototype) {
+prototype = Polymer.Base.chainObject(prototype, Polymer.Base);
+prototype.registerCallback();
+return prototype.constructor;
+};
+window.Polymer = Polymer;
+if (userPolymer) {
+for (var i in userPolymer) {
+Polymer[i] = userPolymer[i];
+}
+}
+Polymer.Class = desugar;
+})();
+
+Polymer.telemetry = {
+registrations: [],
+_regLog: function(prototype) {
+console.log("[" + prototype.is + "]: registered");
+},
+_registrate: function(prototype) {
+this.registrations.push(prototype);
+Polymer.log && this._regLog(prototype);
+},
+dumpRegistrations: function() {
+this.registrations.forEach(this._regLog);
+}
+};
+
+Object.defineProperty(window, "currentImport", {
+enumerable: true,
+configurable: true,
+get: function() {
+return (document._currentScript || document.currentScript).ownerDocument;
+}
+});
+
+Polymer.Base = {
+_addFeature: function(feature) {
+this.extend(this, feature);
+},
+registerCallback: function() {
+this._registerFeatures();
+this._doBehavior("registered");
+},
+createdCallback: function() {
+Polymer.telemetry.instanceCount++;
+this.root = this;
+this._doBehavior("created");
+this._initFeatures();
+},
+attachedCallback: function() {
+this.isAttached = true;
+this._doBehavior("attached");
+},
+detachedCallback: function() {
+this.isAttached = false;
+this._doBehavior("detached");
+},
+attributeChangedCallback: function(name) {
+this._setAttributeToProperty(this, name);
+this._doBehavior("attributeChanged", arguments);
+},
+extend: function(prototype, api) {
+if (prototype && api) {
+Object.getOwnPropertyNames(api).forEach(function(n) {
+this.copyOwnProperty(n, api, prototype);
+}, this);
+}
+return prototype || api;
+},
+copyOwnProperty: function(name, source, target) {
+var pd = Object.getOwnPropertyDescriptor(source, name);
+if (pd) {
+Object.defineProperty(target, name, pd);
+}
+},
+_log: console.log.apply.bind(console.log, console),
+_warn: console.warn.apply.bind(console.warn, console),
+_error: console.error.apply.bind(console.error, console),
+_logf: function() {
+return this._logPrefix.concat([ this.is ]).concat(Array.prototype.slice.call(arguments, 0));
+}
+};
+
+Polymer.Base._logPrefix = function() {
+var color = window.chrome || /firefox/i.test(navigator.userAgent);
+return color ? [ "%c[%s::%s]:", "font-weight: bold; background-color:#EEEE00;" ] : [ "[%s::%s]:" ];
+}();
+
+Polymer.Base.chainObject = function(object, inherited) {
+if (object && inherited && object !== inherited) {
+if (!Object.__proto__) {
+object = Polymer.Base.extend(Object.create(inherited), object);
+}
+object.__proto__ = inherited;
+}
+return object;
+};
+
+Polymer.Base = Polymer.Base.chainObject(Polymer.Base, HTMLElement.prototype);
+
+Polymer.telemetry.instanceCount = 0;
+
+(function() {
+var modules = {};
+var DomModule = function() {
+return document.createElement("dom-module");
+};
+DomModule.prototype = Object.create(HTMLElement.prototype);
+DomModule.prototype.constructor = DomModule;
+DomModule.prototype.createdCallback = function() {
+var id = this.id || this.getAttribute("name") || this.getAttribute("is");
+if (id) {
+this.id = id;
+modules[id] = this;
+}
+};
+DomModule.prototype.import = function(id, slctr) {
+var m = modules[id];
+if (!m) {
+forceDocumentUpgrade();
+m = modules[id];
+}
+if (m && slctr) {
+m = m.querySelector(slctr);
+}
+return m;
+};
+var cePolyfill = window.CustomElements && !CustomElements.useNative;
+if (cePolyfill) {
+var ready = CustomElements.ready;
+CustomElements.ready = true;
+}
+document.registerElement("dom-module", DomModule);
+if (cePolyfill) {
+CustomElements.ready = ready;
+}
+function forceDocumentUpgrade() {
+if (cePolyfill) {
+var script = document._currentScript || document.currentScript;
+if (script) {
+CustomElements.upgradeAll(script.ownerDocument);
+}
+}
+}
+})();
+
+Polymer.Base._addFeature({
+_prepIs: function() {
+if (!this.is) {
+var module = (document._currentScript || document.currentScript).parentNode;
+if (module.localName === "dom-module") {
+var id = module.id || module.getAttribute("name") || module.getAttribute("is");
+this.is = id;
+}
+}
+}
+});
+
+Polymer.Base._addFeature({
+behaviors: [],
+_prepBehaviors: function() {
+if (this.behaviors.length) {
+this.behaviors = this._flattenBehaviorsList(this.behaviors);
+}
+this._prepAllBehaviors(this.behaviors);
+},
+_flattenBehaviorsList: function(behaviors) {
+var flat = [];
+behaviors.forEach(function(b) {
+if (b instanceof Array) {
+flat = flat.concat(this._flattenBehaviorsList(b));
+} else if (b) {
+flat.push(b);
+} else {
+this._warn(this._logf("_flattenBehaviorsList", "behavior is null, check for missing or 404 import"));
+}
+}, this);
+return flat;
+},
+_prepAllBehaviors: function(behaviors) {
+for (var i = behaviors.length - 1; i >= 0; i--) {
+this._mixinBehavior(behaviors[i]);
+}
+for (var i = 0, l = behaviors.length; i < l; i++) {
+this._prepBehavior(behaviors[i]);
+}
+this._prepBehavior(this);
+},
+_mixinBehavior: function(b) {
+Object.getOwnPropertyNames(b).forEach(function(n) {
+switch (n) {
+case "hostAttributes":
+case "registered":
+case "properties":
+case "observers":
+case "listeners":
+case "created":
+case "attached":
+case "detached":
+case "attributeChanged":
+case "configure":
+case "ready":
+break;
+
+default:
+if (!this.hasOwnProperty(n)) {
+this.copyOwnProperty(n, b, this);
+}
+break;
+}
+}, this);
+},
+_doBehavior: function(name, args) {
+this.behaviors.forEach(function(b) {
+this._invokeBehavior(b, name, args);
+}, this);
+this._invokeBehavior(this, name, args);
+},
+_invokeBehavior: function(b, name, args) {
+var fn = b[name];
+if (fn) {
+fn.apply(this, args || Polymer.nar);
+}
+},
+_marshalBehaviors: function() {
+this.behaviors.forEach(function(b) {
+this._marshalBehavior(b);
+}, this);
+this._marshalBehavior(this);
+}
+});
+
+Polymer.Base._addFeature({
+_prepExtends: function() {
+if (this.extends) {
+this.__proto__ = this._getExtendedPrototype(this.extends);
+}
+},
+_getExtendedPrototype: function(tag) {
+return this._getExtendedNativePrototype(tag);
+},
+_nativePrototypes: {},
+_getExtendedNativePrototype: function(tag) {
+var p = this._nativePrototypes[tag];
+if (!p) {
+var np = this.getNativePrototype(tag);
+p = this.extend(Object.create(np), Polymer.Base);
+this._nativePrototypes[tag] = p;
+}
+return p;
+},
+getNativePrototype: function(tag) {
+return Object.getPrototypeOf(document.createElement(tag));
+}
+});
+
+Polymer.Base._addFeature({
+_prepConstructor: function() {
+this._factoryArgs = this.extends ? [ this.extends, this.is ] : [ this.is ];
+var ctor = function() {
+return this._factory(arguments);
+};
+if (this.hasOwnProperty("extends")) {
+ctor.extends = this.extends;
+}
+Object.defineProperty(this, "constructor", {
+value: ctor,
+writable: true,
+configurable: true
+});
+ctor.prototype = this;
+},
+_factory: function(args) {
+var elt = document.createElement.apply(document, this._factoryArgs);
+if (this.factoryImpl) {
+this.factoryImpl.apply(elt, args);
+}
+return elt;
+}
+});
+
+Polymer.nob = Object.create(null);
+
+Polymer.Base._addFeature({
+properties: {},
+getPropertyInfo: function(property) {
+var info = this._getPropertyInfo(property, this.properties);
+if (!info) {
+this.behaviors.some(function(b) {
+return info = this._getPropertyInfo(property, b.properties);
+}, this);
+}
+return info || Polymer.nob;
+},
+_getPropertyInfo: function(property, properties) {
+var p = properties && properties[property];
+if (typeof p === "function") {
+p = properties[property] = {
+type: p
+};
+}
+if (p) {
+p.defined = true;
+}
+return p;
+}
+});
+
+Polymer.CaseMap = {
+_caseMap: {},
+dashToCamelCase: function(dash) {
+var mapped = Polymer.CaseMap._caseMap[dash];
+if (mapped) {
+return mapped;
+}
+if (dash.indexOf("-") < 0) {
+return Polymer.CaseMap._caseMap[dash] = dash;
+}
+return Polymer.CaseMap._caseMap[dash] = dash.replace(/-([a-z])/g, function(m) {
+return m[1].toUpperCase();
+});
+},
+camelToDashCase: function(camel) {
+var mapped = Polymer.CaseMap._caseMap[camel];
+if (mapped) {
+return mapped;
+}
+return Polymer.CaseMap._caseMap[camel] = camel.replace(/([a-z][A-Z])/g, function(g) {
+return g[0] + "-" + g[1].toLowerCase();
+});
+}
+};
+
+Polymer.Base._addFeature({
+_prepAttributes: function() {
+this._aggregatedAttributes = {};
+},
+_addHostAttributes: function(attributes) {
+if (attributes) {
+this.mixin(this._aggregatedAttributes, attributes);
+}
+},
+_marshalHostAttributes: function() {
+this._applyAttributes(this, this._aggregatedAttributes);
+},
+_applyAttributes: function(node, attr$) {
+for (var n in attr$) {
+if (!this.hasAttribute(n) && n !== "class") {
+this.serializeValueToAttribute(attr$[n], n, this);
+}
+}
+},
+_marshalAttributes: function() {
+this._takeAttributesToModel(this);
+},
+_takeAttributesToModel: function(model) {
+for (var i = 0, l = this.attributes.length; i < l; i++) {
+this._setAttributeToProperty(model, this.attributes[i].name);
+}
+},
+_setAttributeToProperty: function(model, attrName) {
+if (!this._serializing) {
+var propName = Polymer.CaseMap.dashToCamelCase(attrName);
+var info = this.getPropertyInfo(propName);
+if (info.defined || this._propertyEffects && this._propertyEffects[propName]) {
+var val = this.getAttribute(attrName);
+model[propName] = this.deserialize(val, info.type);
+}
+}
+},
+_serializing: false,
+reflectPropertyToAttribute: function(name) {
+this._serializing = true;
+this.serializeValueToAttribute(this[name], Polymer.CaseMap.camelToDashCase(name));
+this._serializing = false;
+},
+serializeValueToAttribute: function(value, attribute, node) {
+var str = this.serialize(value);
+(node || this)[str === undefined ? "removeAttribute" : "setAttribute"](attribute, str);
+},
+deserialize: function(value, type) {
+switch (type) {
+case Number:
+value = Number(value);
+break;
+
+case Boolean:
+value = value !== null;
+break;
+
+case Object:
+try {
+value = JSON.parse(value);
+} catch (x) {}
+break;
+
+case Array:
+try {
+value = JSON.parse(value);
+} catch (x) {
+value = null;
+console.warn("Polymer::Attributes: couldn`t decode Array as JSON");
+}
+break;
+
+case Date:
+value = new Date(value);
+break;
+
+case String:
+default:
+break;
+}
+return value;
+},
+serialize: function(value) {
+switch (typeof value) {
+case "boolean":
+return value ? "" : undefined;
+
+case "object":
+if (value instanceof Date) {
+return value;
+} else if (value) {
+try {
+return JSON.stringify(value);
+} catch (x) {
+return "";
+}
+}
+
+default:
+return value != null ? value : undefined;
+}
+}
+});
+
+Polymer.Base._addFeature({
+_setupDebouncers: function() {
+this._debouncers = {};
+},
+debounce: function(jobName, callback, wait) {
+this._debouncers[jobName] = Polymer.Debounce.call(this, this._debouncers[jobName], callback, wait);
+},
+isDebouncerActive: function(jobName) {
+var debouncer = this._debouncers[jobName];
+return debouncer && debouncer.finish;
+},
+flushDebouncer: function(jobName) {
+var debouncer = this._debouncers[jobName];
+if (debouncer) {
+debouncer.complete();
+}
+},
+cancelDebouncer: function(jobName) {
+var debouncer = this._debouncers[jobName];
+if (debouncer) {
+debouncer.stop();
+}
+}
+});
+
+Polymer.version = "1.0.2";
+
+Polymer.Base._addFeature({
+_registerFeatures: function() {
+this._prepIs();
+this._prepAttributes();
+this._prepBehaviors();
+this._prepExtends();
+this._prepConstructor();
+},
+_prepBehavior: function(b) {
+this._addHostAttributes(b.hostAttributes);
+},
+_marshalBehavior: function(b) {},
+_initFeatures: function() {
+this._marshalHostAttributes();
+this._setupDebouncers();
+this._marshalBehaviors();
+}
+});</script>