polymer-rails 0.2.8 → 0.3.0

data/app/assets/javascripts/polymer/src/mini/template.html

@@ -0,0 +1,56 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+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
+-->
+<script>
+
+  /**
+   * Automatic template management.
+   * 
+   * The `template` feature locates and instances a `<template>` element
+   * corresponding to the current Polymer prototype.
+   * 
+   * The `<template>` element may be immediately preceeding the script that 
+   * invokes `Polymer()`.
+   *  
+   * @class standard feature: template
+   */
+  
+  Polymer.Base.addFeature({
+
+    _prepTemplate: function() {
+      // locate template using dom-module
+      this._template = 
+        this._template || Polymer.DomModule.import(this.is, 'template');
+      // fallback to look at the node previous to the currentScript.
+      if (!this._template) {
+        var script = document._currentScript || document.currentScript;
+        var prev = script && script.previousElementSibling;
+        if (prev && prev.localName === 'template') {
+          this._template = prev;
+        }
+      }
+    },
+
+    _stampTemplate: function() {
+      if (this._template) {
+        // note: root is now a fragment which can be manipulated
+        // while not attached to the element.
+        this.root = this.instanceTemplate(this._template);
+      }
+    },
+
+    instanceTemplate: function(template) {
+      var dom = 
+        document.importNode(template._content || template.content, true);
+      return dom;
+    }
+
+  });
+
+</script>

data/app/assets/javascripts/polymer/src/polymer-lib.html

@@ -0,0 +1,15 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+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="lib/settings.html">
+<link rel="import" href="lib/polymer-bootstrap.html">
+<link rel="import" href="lib/lang.html">
+<link rel="import" href="lib/base.html">
+<link rel="import" href="lib/dom-module.html">

data/app/assets/javascripts/polymer/src/standard/annotations.html

@@ -0,0 +1,198 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+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
+-->
+
+<!-- employ 'Annotations' module -->
+
+<link rel="import" href="../lib/annotations/annotations.html">
+<link rel="import" href="../lib/resolve-url.html">
+<script>
+
+/**
+ * Scans a template to produce an annotation object that stores expression 
+ * metadata along with information to associate the metadata with nodes in an 
+ * instance.
+ *
+ * Elements with `id` in the template are noted and marshaled into an 
+ * the `$` hash in an instance. 
+ * 
+ * Example
+ * 
+ *     &lt;template>
+ *       &lt;div id="foo">&lt;/div>
+ *     &lt;/template>
+ *     &lt;script>
+ *      Polymer({
+ *        task: function() {
+ *          this.$.foo.style.color = 'red';
+ *        }
+ *      });
+ *     &lt;/script>
+ * 
+ * Other expressions that are noted include:
+ *
+ * Double-mustache annotations in text content. The annotation must be the only
+ * content in the tag, compound expressions are not (currently) supported.
+ *
+ *     <[tag]>{{path.to.host.property}}<[tag]>
+ *
+ * Double-mustache annotations in an attribute.
+ *
+ *     <[tag] someAttribute="{{path.to.host.property}}"><[tag]>
+ *
+ * Only immediate host properties can automatically trigger side-effects.
+ * Setting `host.path` in the example above triggers the binding, setting
+ * `host.path.to.host.property` does not.
+ *
+ * `on-` style event declarations.
+ *
+ *     <[tag] on-<event-name>="{{hostMethodName}}"><[tag]>
+ *
+ * Note: **the `annotations` feature does not actually implement the behaviors
+ * associated with these expressions, it only captures the data**. 
+ * 
+ * Other optional features contain actual data implementations.
+ *
+ * @class standard feature: annotations
+ */
+
+/*
+
+Scans a template to produce an annotation map that stores expression metadata
+and information that associates the metadata to nodes in a template instance.
+
+Supported annotations are:
+
+  * id attributes
+  * binding annotations in text nodes
+    * double-mustache expressions: {{expression}}
+    * double-bracket expressions: [[expression]]
+  * binding annotations in attributes
+    * attribute-bind expressions: name="{{expression}} || [[expression]]"
+    * property-bind expressions: name*="{{expression}} || [[expression]]"
+    * property-bind expressions: name:="expression"
+  * event annotations
+    * event delegation directives: on-<eventName>="expression"
+
+Generated data-structure:
+
+  [
+    {
+      id: '<id>',
+      events: [
+        {
+          mode: ['auto'|''],
+          name: '<name>'
+          value: '<expression>'
+        }, ...
+      ],
+      bindings: [
+        {
+          kind: ['text'|'attribute'|'property'],
+          mode: ['auto'|''],
+          name: '<name>'
+          value: '<expression>'
+        }, ...
+      ],
+      // TODO(sjmiles): confusingly, this is annotation-parent, not node-parent
+      parent: <reference to parent annotation>,
+      index: <integer index in parent's childNodes collection>
+    },
+    ...
+  ]
+
+TODO(sjmiles): this module should produce either syntactic metadata
+(e.g. double-mustache, double-bracket, star-attr), or semantic metadata
+(e.g. manual-bind, auto-bind, property-bind). Right now it's half and half.
+
+*/
+
+  Polymer.Base.addFeature({
+
+    // registration-time
+
+    _prepAnnotations: function() {
+      if (!this._template) {
+        this._annotes = [];
+      } else {
+        // TODO(sorvell): ad hoc method of plugging behavior into Annotations
+        Polymer.Annotations.prepElement = this._prepElement.bind(this);
+        this._annotes = Polymer.Annotations.parseAnnotations(this._template);
+        Polymer.Annotations.prepElement = null;
+      }
+    },
+
+    _prepElement: function(element) {
+      Polymer.ResolveUrl.resolveAttrs(element, this._template.ownerDocument);
+    },
+
+    // instance-time
+
+    findAnnotatedNode: Polymer.Annotations.findAnnotatedNode,
+
+    // marshal all teh things
+    _marshalAnnotationReferences: function() {
+      if (this._template) {
+        this._marshalIdNodes();
+        this._marshalAnnotatedNodes();
+        this._marshalAnnotatedListeners();
+      }
+    },
+
+    // push configuration references at configure time
+    _configureAnnotationReferences: function() {
+      this._configureTemplateContent();
+    },
+
+    // nested template contents have been stored prototypically to avoid 
+    // unnecessary duplication, here we put references to the 
+    // indirected contents onto the nested template instances
+    _configureTemplateContent: function() {
+      this._annotes.forEach(function(note) {
+        if (note.templateContent) {
+          var template = this.findAnnotatedNode(this.root, note);
+          template._content = note.templateContent;
+        }
+      }, this);
+    },
+
+    // construct `$` map (from id annotations)
+    _marshalIdNodes: function() {
+      this.$ = {};
+      this._annotes.forEach(function(a) {
+        if (a.id) {
+          this.$[a.id] = this.findAnnotatedNode(this.root, a);
+        }
+      }, this);
+    },
+
+    // concretize `_nodes` map (from anonymous annotations)
+    _marshalAnnotatedNodes: function() {
+      if (this._nodes) {
+        this._nodes = this._nodes.map(function(a) {
+          return this.findAnnotatedNode(this.root, a);
+        }, this);
+      }
+    },
+
+    // install event listeners (from event annotations)
+    _marshalAnnotatedListeners: function() {
+      this._annotes.forEach(function(a) {
+        if (a.events && a.events.length) {
+          var node = this.findAnnotatedNode(this.root, a);
+          a.events.forEach(function(e) {
+            this.listen(node, e.name, e.value);
+          }, this);
+        }
+      }, this);
+    }
+
+  });
+
+</script>

data/app/assets/javascripts/polymer/src/standard/configure.html

@@ -0,0 +1,160 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+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
+-->
+
+<script>
+
+  /*
+    Process inputs efficiently via a configure lifecycle callback.
+    Configure is called top-down, host before local dom. Users should 
+    implement configure to supply a set of default values for the element by 
+    returning an object containing the properties and values to set.
+
+    Configured values are not immediately set, instead they are set when 
+    an element becomes ready, after its local dom is ready. This ensures
+    that any user change handlers are not called before ready time.
+
+  */
+
+  /*
+  Implementation notes:
+
+  Configured values are collected into _config. At ready time, properties
+  are set to the values in _config. This ensures properties are set child
+  before host and change handlers are called only at ready time. The host
+  will reset a value already propagated to a child, but this is not 
+  inefficient because of dirty checking at the set point.
+
+  Bind notification events are sent when properties are set at ready time
+  and thus received by the host before it is ready. Since notifications result
+  in property updates and this triggers side effects, handling notifications
+  is deferred until ready time.
+
+  In general, events can be heard before an element is ready. This may occur 
+  when a user sends an event in a change handler or listens to a data event
+  directly (on-foo-changed).
+  */
+
+  Polymer.Base.addFeature({
+
+    // storage for configuration
+    _setupConfigure: function(initialConfig) {
+      this._config = initialConfig || {};
+      this._handlers = [];
+    },
+
+    // static attributes are deserialized into _config
+    _takeAttributes: function() {
+      this._takeAttributesToModel(this._config);
+    },
+
+    // at configure time values are stored in _config
+    _configValue: function(name, value) {
+      this._config[name] = value;
+    },
+
+    // configure: returns user supplied default property values
+    // combines with _config to create final property values
+    _configure: function() {
+      this._configureAnnotationReferences();
+      var i;
+      // get individual default values from property config
+      var config = {};
+      for (i in this.properties) {
+        var c = this.properties[i];
+        if (c.value !== undefined) {
+          if (typeof c.value == 'function') {
+            config[i] = c.value.call(this, this._config);
+          } else {
+            config[i] = c.value;
+          }
+        }
+      }
+      // get add'l default values from central configure 
+      this.simpleMixin(config, this.configure(this._config));
+      // combine defaults returned from configure with inputs in _config
+      this.simpleMixin(config, this._config);
+      // this is the new _config, which are the final values to be applied
+      this._config = config;
+      // pass configuration data to bindings
+      this._distributeConfig(this._config);
+    },
+
+    simpleMixin: function(a, b) {
+      for (var i in b) {
+        a[i] = b[i];
+      }
+    },
+
+    // distribute config values to bound nodes.
+    _distributeConfig: function(config) {
+      var fx$ = this._propertyEffects;
+      if (fx$) {
+        for (var p in config) {
+          var fx = fx$[p];
+          if (fx) {
+            for (var i=0, l=fx.length, x; (i<l) && (x=fx[i]); i++) {
+              if (x.kind === 'annotation') {
+                var node = this._nodes[x.effect.index];
+                // seeding configuration only
+                if (node._configValue) {
+                  var value = (p === x.effect.value) ? config[p] :
+                    this.getPathValue(x.effect.value, config);
+                  node._configValue(x.effect.name, value);
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+
+    _beforeReady: function() {
+      this._applyConfig(this._config);
+      this._flushHandlers();
+    },
+
+    // NOTE: values are already propagated to children via 
+    // _distributeConfig so propagation triggered by effects here is 
+    // redundant, but safe due to dirty checking
+    _applyConfig: function(config) {
+      for (var n in config) {
+        // Don't stomp on values that may have been set by other side effects
+        if (this[n] === undefined) {
+          this[n] = config[n];
+        }
+      }
+    },
+
+    // NOTE: Notifications can be processed before ready since
+    // they are sent at *child* ready time. Since notifications cause side
+    // effects and side effects must not be processed before ready time,
+    // handling is queue/defered until then.
+    _notifyListener: function(fn, e) {
+      if (!this._readied) {
+        this._queueHandler([fn, e, e.target]);
+      } else {
+        return fn.call(this, e, e.target);
+      }
+    },
+
+    _queueHandler: function(args) {
+      this._handlers.push(args);
+    },
+
+    _flushHandlers: function() {
+      var h$ = this._handlers;
+      for (var i=0, l=h$.length, h; (i<l) && (h=h$[i]); i++) {
+        h[0].call(this, h[1], h[2]);
+      }
+    }
+
+  });
+
+</script>

data/app/assets/javascripts/polymer/src/standard/effects.html

@@ -0,0 +1,215 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+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="../lib/bind/accessors.html">
+<link rel="import" href="../lib/bind/effects.html">
+
+<script>
+
+  /**
+   * Support for the declarative property sugaring via mustache `{{ }}`
+   * annotations in templates, and via the `properties` objects on
+   * prototypes.
+   *
+   * Example:
+   *
+   *     <template>
+   *       <span hidden="{{hideSpan}}">{{name}}</span> is on the hook.
+   *     </template>
+   *
+   * The `properties` object syntax is as follows:
+   *
+   *     Polymer({
+   *
+   *       properties: {
+   *         myProp: {
+   *           observer: 'myPropChanged',
+   *           computed: 'computemyProp(input1, input2)'
+   *         }
+   *       }
+   *
+   *       ...
+   *
+   *     });
+   *
+   * The `bind` feature also provides an API for registering effects against
+   * properties.
+   *
+   * Property effects can be created imperatively, by template-annotations
+   * (e.g. mustache notation), or by declaration in the `properties` object.
+   *
+   * The effect data is consumed by the `bind` subsystem (`/src/bind/*`),
+   * which compiles the effects into efficient JavaScript that is triggered,
+   * e.g., when a property is set to a new value.
+   *
+   * @class data feature: bind
+   */
+
+  Polymer.Base.addFeature({
+
+    _addPropertyEffect: function(property, kind, effect) {
+     // TODO(sjmiles): everything to the right of the first '.' is lost, implies
+     // there is some duplicate information flow (not the only sign)
+     var model = property.split('.').shift();
+     Polymer.Bind.addPropertyEffect(this, model, kind, effect);
+    },
+
+    // prototyping
+
+    _prepEffects: function() {
+      Polymer.Bind.prepareModel(this);
+      this._addPropertyEffects(this.properties);
+      this._addObserverEffects(this.observers);
+      this._addAnnotationEffects(this._annotes);
+      Polymer.Bind.createBindings(this);
+    },
+
+    _addPropertyEffects: function(effects) {
+      if (effects) {
+        for (var n in effects) {
+          var effect = effects[n];
+          if (effect.observer) {
+            this._addObserverEffect(n, effect.observer);
+          }
+          if (effect.computed) {
+            this._addComputedEffect(n, effect.computed);
+          }
+          if (this.isNotifyProperty(n)) {
+            this._addPropertyEffect(n, 'notify');
+          }
+          if (this.isReflectedProperty(n)) {
+            this._addPropertyEffect(n, 'reflect');
+          }
+        }
+      }
+    },
+
+    _addComputedEffect: function(name, expression) {
+      var index = expression.indexOf('(');
+      var method = expression.slice(0, index);
+      var args = expression.slice(index + 1, -1).replace(/ /g, '').split(',');
+      //console.log('%c on [%s] compute [%s] via [%s]', 'color: green', args[0], name, method);
+      var effect = {
+        property: name,
+        args: args,
+        methodName: method
+      };
+      for (var i=0; i<args.length; i++) {
+        this._addPropertyEffect(args[i], 'compute', effect);
+      }
+    },
+
+    _addObserverEffects: function(effects) {
+      for (var n in effects) {
+        this._addObserverEffect(n, effects[n]);
+      }
+    },
+
+    _addObserverEffect: function(property, observer) {
+      var effect = {
+        method: observer
+      };
+      var props = property.split(' ');
+      if (props.length == 1) {
+        // Single property synchronous observer (supports paths)
+        var model = property.split('.').shift();
+        if (model != property) {
+          // TODO(kschaaf): path observers won't get the right `new` argument
+          this.addPathObserver(property, observer);
+        }
+        effect.property = model;
+        this._addPropertyEffect(model, 'observer', effect);
+      } else {
+        // Multiple-property observer
+        effect.properties = props;
+        for (var i=0, l=props.length; i<l; i++) {
+          this._addPropertyEffect(props[i], 'observer', effect);
+        }
+      }
+    },
+
+    _addAnnotationEffects: function(effects) {
+      // create a virtual annotation list, must be concretized at instance time
+      this._nodes = [];
+      // process annotations that have been parsed from template
+      effects.forEach(function(note) {
+        // where to find the node in the concretized list
+        var index = this._nodes.push(note) - 1;
+        note.bindings.forEach(function(effect) {
+          this._addAnnotationEffect(effect, index);
+        }, this);
+      }, this);
+    },
+
+    _addAnnotationEffect: function(effect, index) {
+      // TODO(sjmiles): annotations have 'effects' proper and 'listener'
+      if (Polymer.Bind._shouldAddListener(effect)) {
+        // <node>.on.<dash-case-property>-changed: <path> = e.detail.value
+        Polymer.Bind._addAnnotatedListener(this, index,
+          effect.name, effect.value, effect.event);
+      }
+      var computed = effect.value.match(/(\w*)\((.*)\)/);
+      if (computed) {
+        var method = computed[1];
+        var args = computed[2].split(/[^\w]+/);
+        this._addAnnotatedComputationEffect(method, args, effect, index);
+      } else {
+        // capture the node index
+        effect.index = index;
+        // discover top-level property (model) from path
+        var model = effect.value.split('.').shift();
+        // add 'annotation' binding effect for property 'model'
+        this._addPropertyEffect(model, 'annotation', effect);
+      }
+    },
+
+    _addAnnotatedComputationEffect: function(method, args, info, index) {
+      var effect = {
+        kind: info.kind,
+        property: info.name,
+        index: index,
+        args: args,
+        methodName: method
+      };
+      for (var i=0, l=args.length; i<l; i++) {
+        this._addPropertyEffect(args[i], 'annotatedComputation', effect);
+      }
+    },
+
+    // instancing
+
+    _marshalInstanceEffects: function() {
+      Polymer.Bind.prepareInstance(this);
+      Polymer.Bind.setupBindListeners(this);
+    },
+
+    _applyEffectValue: function(value, info) {
+      var node = this._nodes[info.index];
+      // TODO(sorvell): ideally, the info object is normalized for easy 
+      // lookup here.
+      var property = info.property || info.name || 'textContent';
+      // TODO(sorvell): consider pre-processing this step so we don't need
+      // this lookup.
+      // if (info._class === undefined) {
+      //   info._class = (property === 'class' || property === 'className');
+      // }
+      // if (info._class) {
+      //   value = this._scopeElementClass(node, value);
+      // }
+      if (info.kind == 'attribute') {
+        this.serializeValueToAttribute(value, property, node);
+      } else {
+        return node[property] = value;
+      }
+    }
+
+  });
+
+</script>