polymer-rails 0.3.0 → 1.0.0

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

@@ -1,56 +0,0 @@
-<!--
-@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

@@ -1,15 +0,0 @@
-<!--
-@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

@@ -1,198 +0,0 @@
-<!--
-@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

@@ -1,160 +0,0 @@
-<!--
-@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

@@ -1,215 +0,0 @@
-<!--
-@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>