polymer-core-rails 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 761a9f4361f721df4014b23c8238683010ff63e0
-  data.tar.gz: 0a5c65e4667e44b7823a480c4cf841b833bcfd93
+  metadata.gz: 0d53a57bb41b3734b6c966d5521a9c106919db1b
+  data.tar.gz: 2b31752e1e041b56bafaa576706c5e366b8544aa
 SHA512:
-  metadata.gz: 0b8d66ba7ece25d2c8ca40973011c0462ea5f35c67ae4876ea18269ac05a8529dbdead3684752a9307bf86af06946b7bf6b348eedc947587ca1ca26a5cb0f335
-  data.tar.gz: 1d8ce175b6cdbb7d5f3caaf64c7e144b1b8a6494029aae3fde54879368a87c7922ba83e47064d62ff1688408329de009156a5329f3fde1770e4c325f1763a290
+  metadata.gz: 298b871833a9ef30478380cbb39fb4aa6b0c9fe3ef602a5fd67fa3528561c3ae8348f4d4c74644804b73502b91e378ac34a4c4a6290f4de4c2e72797a531922c
+  data.tar.gz: f3a31a30f710a3090ff7bcb961a6441abe6c427b1691a506719c22b7ab7ce8d3e5602cbbba477687148759d379c4872c3270f24c8dd42655f2b7b53c52c0f9a8

data/app/assets/components/context-free-parser/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "polymer-context-free-parser",
+  "version": "0.4.2",
+  "description": "context-free-parser scrapes source documentation data from input text or url.",
+  "main": "context-free-parser.js",
+  "repository": {
+    "type": "git",
+    "url": "ssh://git@github.com/Polymer/context-free-parser.git"
+  },
+  "author": "The Polymer Authors",
+  "license": "BSD",
+  "bugs": {
+    "url": "https://github.com/Polymer/context-free-parser/issues"
+  },
+  "homepage": "https://github.com/Polymer/context-free-parser"
+}

data/app/assets/components/core-a11y-keys/core-a11y-keys.html

@@ -0,0 +1,335 @@
+<!--
+    @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
+-->
+
+<!--
+`core-a11y-keys` provides a normalized interface for processing keyboard commands that pertain to [WAI-ARIA best
+practices](http://www.w3.org/TR/wai-aria-practices/#kbd_general_binding). The element takes care of browser differences
+with respect to Keyboard events and uses an expressive syntax to filter key presses.
+
+Use the `keys` attribute to express what combination of keys will trigger the event to fire.
+
+Use the `target` attribute to set up event handlers on a specific node.
+The `keys-pressed` event will fire when one of the key combinations set with the `keys` attribute is pressed.
+
+Example:
+
+This element will call `arrowHandler` on all arrow keys:
+
+    <core-a11y-keys target="{{}}" keys="up down left right" on-keys-pressed="{{arrowHandler}}"></core-a11y-keys>
+
+Keys Syntax:
+
+The `keys` attribute can accepts a space seprated, `+` concatenated set of modifier keys and some common keyboard keys.
+
+The common keys are `a-z`, `0-9` (top row and number pad), `*` (shift 8 and number pad), `F1-F12`, `Page Up`, `Page
+Down`, `Left Arrow`, `Right Arrow`, `Down Arrow`, `Up Arrow`, `Home`, `End`, `Escape`, `Space`, `Tab`, and `Enter` keys.
+
+The modifier keys are `Shift`, `Control`, and `Alt`.
+
+All keys are expected to be lowercase and shortened:
+`Left Arrow` is `left`, `Page Down` is `pagedown`, `Control` is `ctrl`, `F1` is `f1`, `Escape` is `esc` etc.
+
+Keys Syntax Example:
+
+Given the `keys` attribute value "ctrl+shift+f7 up pagedown esc space alt+m", the `<core-a11y-keys>` element will send
+the `keys-pressed` event if any of the follow key combos are pressed: Control and Shift and F7 keys, Up Arrow key, Page
+Down key, Escape key, Space key, Alt and M key.
+
+Slider Example:
+
+The following is an example of the set of keys that fulfil the WAI-ARIA "slider" role [best
+practices](http://www.w3.org/TR/wai-aria-practices/#slider):
+
+    <core-a11y-keys target="{{}}" keys="left pagedown down" on-keys-pressed="{{decrement}}"></core-a11y-keys>
+    <core-a11y-keys target="{{}}" keys="right pageup up" on-keys-pressed="{{increment}}"></core-a11y-keys>
+    <core-a11y-keys target="{{}}" keys="home" on-keys-pressed="{{setMin}}"></core-a11y-keys>
+    <core-a11y-keys target="{{}}" keys="end" on-keys-pressed="{{setMax}}"></core-a11y-keys>
+
+The `increment` function will move the slider a set amount toward the maximum value.
+The `decrement` function will move the slider a set amount toward the minimum value.
+The `setMin` function will move the slider to the minimum value.
+The `setMax` function will move the slider to the maximum value.
+
+Keys Syntax Grammar:
+
+[EBNF](http://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_Form) Grammar of the `keys` attribute.
+
+    modifier = "shift" | "ctrl" | "alt";
+    ascii = ? /[a-z0-9]/ ? ;
+    fnkey = ? f1 through f12 ? ;
+    arrow = "up" | "down" | "left" | "right" ;
+    key = "tab" | "esc" | "space" | "*" | "pageup" | "pagedown" | "home" | "end" | arrow | ascii | fnkey ;
+    keycombo = { modifier, "+" }, key ;
+    keys = keycombo, { " ", keycombo } ;
+
+@group Core Elements
+@element core-a11y-keys
+@homepage github.io
+-->
+
+<link rel="import" href="../polymer/polymer.html">
+
+<style shim-shadowdom>
+  html /deep/ core-a11y-keys {
+    display: none;
+  }
+</style>
+
+<polymer-element name="core-a11y-keys">
+<script>
+  (function() {
+    /*
+     * Chrome uses an older version of DOM Level 3 Keyboard Events
+     *
+     * Most keys are labeled as text, but some are Unicode codepoints.
+     * Values taken from: http://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/keyset.html#KeySet-Set
+     */
+    var KEY_IDENTIFIER = {
+      'U+0009': 'tab',
+      'U+001B': 'esc',
+      'U+0020': 'space',
+      'U+002A': '*',
+      'U+0030': '0',
+      'U+0031': '1',
+      'U+0032': '2',
+      'U+0033': '3',
+      'U+0034': '4',
+      'U+0035': '5',
+      'U+0036': '6',
+      'U+0037': '7',
+      'U+0038': '8',
+      'U+0039': '9',
+      'U+0041': 'a',
+      'U+0042': 'b',
+      'U+0043': 'c',
+      'U+0044': 'd',
+      'U+0045': 'e',
+      'U+0046': 'f',
+      'U+0047': 'g',
+      'U+0048': 'h',
+      'U+0049': 'i',
+      'U+004A': 'j',
+      'U+004B': 'k',
+      'U+004C': 'l',
+      'U+004D': 'm',
+      'U+004E': 'n',
+      'U+004F': 'o',
+      'U+0050': 'p',
+      'U+0051': 'q',
+      'U+0052': 'r',
+      'U+0053': 's',
+      'U+0054': 't',
+      'U+0055': 'u',
+      'U+0056': 'v',
+      'U+0057': 'w',
+      'U+0058': 'x',
+      'U+0059': 'y',
+      'U+005A': 'z',
+      'U+007F': 'del'
+    };
+
+    /*
+     * Special table for KeyboardEvent.keyCode.
+     * KeyboardEvent.keyIdentifier is better, and KeyBoardEvent.key is even better than that
+     *
+     * Values from: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent.keyCode#Value_of_keyCode
+     */
+    var KEY_CODE = {
+      9: 'tab',
+      13: 'enter',
+      27: 'esc',
+      33: 'pageup',
+      34: 'pagedown',
+      35: 'end',
+      36: 'home',
+      32: 'space',
+      37: 'left',
+      38: 'up',
+      39: 'right',
+      40: 'down',
+      46: 'del',
+      106: '*'
+    };
+
+    /*
+     * KeyboardEvent.key is mostly represented by printable character made by the keyboard, with unprintable keys labeled
+     * nicely.
+     *
+     * However, on OS X, Alt+char can make a Unicode character that follows an Apple-specific mapping. In this case, we
+     * fall back to .keyCode.
+     */
+    var KEY_CHAR = /[a-z0-9*]/;
+
+    function transformKey(key) {
+      var validKey = '';
+      if (key) {
+        var lKey = key.toLowerCase();
+        if (lKey.length == 1) {
+          if (KEY_CHAR.test(lKey)) {
+            validKey = lKey;
+          }
+        } else if (lKey == 'multiply') {
+          // numpad '*' can map to Multiply on IE/Windows
+          validKey = '*';
+        } else {
+          validKey = lKey;
+        }
+      }
+      return validKey;
+    }
+
+    var IDENT_CHAR = /U\+/;
+    function transformKeyIdentifier(keyIdent) {
+      var validKey = '';
+      if (keyIdent) {
+        if (IDENT_CHAR.test(keyIdent)) {
+          validKey = KEY_IDENTIFIER[keyIdent];
+        } else {
+          validKey = keyIdent.toLowerCase();
+        }
+      }
+      return validKey;
+    }
+
+    function transformKeyCode(keyCode) {
+      var validKey = '';
+      if (Number(keyCode)) {
+        if (keyCode >= 65 && keyCode <= 90) {
+          // ascii a-z
+          // lowercase is 32 offset from uppercase
+          validKey = String.fromCharCode(32 + keyCode);
+        } else if (keyCode >= 112 && keyCode <= 123) {
+          // function keys f1-f12
+          validKey = 'f' + (keyCode - 112);
+        } else if (keyCode >= 48 && keyCode <= 57) {
+          // top 0-9 keys
+          validKey = String(48 - keyCode);
+        } else if (keyCode >= 96 && keyCode <= 105) {
+          // num pad 0-9
+          validKey = String(96 - keyCode);
+        } else {
+          validKey = KEY_CODE[keyCode];
+        }
+      }
+      return validKey;
+    }
+
+    function keyboardEventToKey(ev) {
+      // fall back from .key, to .keyIdentifier, and then to .keyCode
+      var normalizedKey = transformKey(ev.key) || transformKeyIdentifier(ev.keyIdentifier) || transformKeyCode(ev.keyCode) || '';
+      return {
+        shift: ev.shiftKey,
+        ctrl: ev.ctrlKey,
+        meta: ev.metaKey,
+        alt: ev.altKey,
+        key: normalizedKey
+      };
+    }
+
+    /*
+     * Input: ctrl+shift+f7 => {ctrl: true, shift: true, key: 'f7'}
+     * ctrl/space => {ctrl: true} || {key: space}
+     */
+    function stringToKey(keyCombo) {
+      var keys = keyCombo.split('+');
+      var keyObj = Object.create(null);
+      keys.forEach(function(key) {
+        if (key == 'shift') {
+          keyObj.shift = true;
+        } else if (key == 'ctrl') {
+          keyObj.ctrl = true;
+        } else if (key == 'alt') {
+          keyObj.alt = true;
+        } else {
+          keyObj.key = key;
+        }
+      });
+      return keyObj;
+    }
+
+    function keyMatches(a, b) {
+      return Boolean(a.alt) == Boolean(b.alt) && Boolean(a.ctrl) == Boolean(b.ctrl) && Boolean(a.shift) == Boolean(b.shift) && a.key === b.key;
+    }
+
+    /**
+     * Fired when a keycombo in `keys` is pressed.
+     *
+     * @event keys-pressed
+     */
+    function processKeys(ev) {
+      var current = keyboardEventToKey(ev);
+      for (var i = 0, dk; i < this._desiredKeys.length; i++) {
+        dk = this._desiredKeys[i];
+        if (keyMatches(dk, current)) {
+          ev.preventDefault();
+          ev.stopPropagation();
+          this.fire('keys-pressed', current, this, false);
+          break;
+        }
+      }
+    }
+
+    function listen(node, handler) {
+      if (node && node.addEventListener) {
+        node.addEventListener('keydown', handler);
+      }
+    }
+
+    function unlisten(node, handler) {
+      if (node && node.removeEventListener) {
+        node.removeEventListener('keydown', handler);
+      }
+    }
+
+    Polymer('core-a11y-keys', {
+      created: function() {
+        this._keyHandler = processKeys.bind(this);
+      },
+      attached: function() {
+        if (!this.target) {
+          this.target = this.parentNode;
+        }
+        listen(this.target, this._keyHandler);
+      },
+      detached: function() {
+        unlisten(this.target, this._keyHandler);
+      },
+      publish: {
+        /**
+         * The set of key combinations to listen for.
+         *
+         * @attribute keys
+         * @type string (keys syntax)
+         * @default ''
+         */
+        keys: '',
+        /**
+         * The node that will fire keyboard events.
+         * Default to this element's parentNode unless one is assigned
+         *
+         * @attribute target
+         * @type Node
+         * @default this.parentNode
+         */
+        target: null
+      },
+      keysChanged: function() {
+        // * can have multiple mappings: shift+8, * on numpad or Multiply on numpad
+        var normalized = this.keys.replace('*', '* shift+*');
+        this._desiredKeys = normalized.toLowerCase().split(' ').map(stringToKey);
+      },
+      targetChanged: function(oldTarget) {
+        unlisten(oldTarget, this._keyHandler);
+        listen(this.target, this._keyHandler);
+      }
+    });
+  })();
+</script>
+</polymer-element>

data/app/assets/components/core-ajax/core-ajax.html

@@ -18,9 +18,9 @@ The `core-ajax` element exposes `XMLHttpRequest` functionality.
         params='{"alt":"json", "q":"chrome"}'
         handleAs="json"
         on-core-response="{{handleResponse}}"></core-ajax>
- 
+
 With `auto` set to `true`, the element performs a request whenever
-its `url` or `params` properties are changed.
+its `url`, `params` or `body` properties are changed.
 
 Note: The `params` attribute must be double quoted JSON.
 
@@ -32,19 +32,19 @@ element.
 @homepage github.io
 -->
 <link rel="import" href="core-xhr.html">
-<polymer-element name="core-ajax" hidden attributes="url handleAs auto params response method headers body contentType withCredentials">
+<polymer-element name="core-ajax" hidden attributes="url handleAs auto params response error method headers body contentType withCredentials progress loading">
 <script>
 
   Polymer('core-ajax', {
     /**
      * Fired when a response is received.
-     * 
+     *
      * @event core-response
      */
 
     /**
      * Fired when an error is received.
-     * 
+     *
      * @event core-error
      */
 
@@ -56,7 +56,7 @@ element.
 
     /**
      * The URL target of the request.
-     * 
+     *
      * @attribute url
      * @type string
      * @default ''
@@ -66,13 +66,13 @@ element.
     /**
      * Specifies what data to store in the `response` property, and
      * to deliver as `event.response` in `response` events.
-     * 
+     *
      * One of:
-     * 
+     *
      *    `text`: uses `XHR.responseText`.
-     *    
+     *
      *    `xml`: uses `XHR.responseXML`.
-     *    
+     *
      *    `json`: uses `XHR.responseText` parsed as JSON.
      *
      *    `arraybuffer`: uses `XHR.response`.
@@ -80,7 +80,7 @@ element.
      *    `blob`: uses `XHR.response`.
      *
      *    `document`: uses `XHR.response`.
-     *  
+     *
      * @attribute handleAs
      * @type string
      * @default 'text'
@@ -98,7 +98,7 @@ element.
 
     /**
      * Parameters to send to the specified URL, as JSON.
-     *  
+     *
      * @attribute params
      * @type string (JSON)
      * @default ''
@@ -106,7 +106,8 @@ element.
     params: '',
 
     /**
-     * Returns the response object.
+     * The response for the current request, or null if it hasn't
+     * completed yet or the request resulted in error.
      *
      * @attribute response
      * @type Object
@@ -114,6 +115,34 @@ element.
      */
     response: null,
 
+    /**
+     * The error for the current request, or null if it hasn't
+     * completed yet or the request resulted in success.
+     *
+     * @attribute error
+     * @type Object
+     * @default null
+     */
+    error: null,
+
+    /**
+     * Whether the current request is currently loading.
+     *
+     * @attribute loading
+     * @type boolean
+     * @default false
+     */
+    loading: false,
+
+    /**
+     * The progress of the current request.
+     *
+     * @attribute progress
+     * @type {loaded: number, total: number, lengthComputable: boolean}
+     * @default {}
+     */
+    progress: null,
+
     /**
      * The HTTP method to use such as 'GET', 'POST', 'PUT', or 'DELETE'.
      * Default is 'GET'.
@@ -129,13 +158,13 @@ element.
      *
      * Example:
      *
-     *     <core-ajax 
+     *     <core-ajax
      *         auto
      *         url="http://somesite.com"
      *         headers='{"X-Requested-With": "XMLHttpRequest"}'
      *         handleAs="json"
      *         on-core-response="{{handleResponse}}"></core-ajax>
-     *  
+     *
      * @attribute headers
      * @type Object
      * @default null
@@ -150,7 +179,7 @@ element.
      *     <core-ajax method="POST" auto url="http://somesite.com"
      *         body='{"foo":1, "bar":2}'>
      *     </core-ajax>
-     *  
+     *
      * @attribute body
      * @type Object
      * @default null
@@ -168,26 +197,30 @@ element.
 
     /**
      * Set the withCredentials flag on the request.
-     * 
+     *
      * @attribute withCredentials
      * @type boolean
      * @default false
      */
     withCredentials: false,
-    
+
     /**
      * Additional properties to send to core-xhr.
      *
      * Can be set to an object containing default properties
      * to send as arguments to the `core-xhr.request()` method
      * which implements the low-level communication.
-     * 
+     *
      * @property xhrArgs
      * @type Object
      * @default null
      */
     xhrArgs: null,
-     
+
+    created: function() {
+      this.progress = {};
+    },
+
     ready: function() {
       this.xhr = document.createElement('core-xhr');
     },
@@ -196,7 +229,7 @@ element.
       if (this.isSuccess(xhr)) {
         this.processResponse(xhr);
       } else {
-        this.error(xhr);
+        this.processError(xhr);
       }
       this.complete(xhr);
     },
@@ -208,16 +241,40 @@ element.
 
     processResponse: function(xhr) {
       var response = this.evalResponse(xhr);
-      this.response = response;
+      if (xhr === this.activeRequest) {
+        this.response = response;
+      }
       this.fire('core-response', {response: response, xhr: xhr});
     },
 
-    error: function(xhr) {
+    processError: function(xhr) {
       var response = xhr.status + ': ' + xhr.responseText;
+      if (xhr === this.activeRequest) {
+        this.error = response;
+      }
       this.fire('core-error', {response: response, xhr: xhr});
     },
 
+    processProgress: function(progress, xhr) {
+      if (xhr !== this.activeRequest) {
+        return;
+      }
+      // We create a proxy object here because these fields
+      // on the progress event are readonly properties, which
+      // causes problems in common use cases (e.g. binding to
+      // <paper-progress> attributes).
+      var progressProxy = {
+        lengthComputable: progress.lengthComputable,
+        loaded: progress.loaded,
+        total: progress.total
+      }
+      this.progress = progressProxy;
+    },
+
     complete: function(xhr) {
+      if (xhr === this.activeRequest) {
+        this.loading = false;
+      }
       this.fire('core-complete', {response: xhr.status, xhr: xhr});
     },
 
@@ -273,12 +330,16 @@ element.
       this.autoGo();
     },
 
+    bodyChanged: function() {
+      this.autoGo();
+    },
+
     autoChanged: function() {
       this.autoGo();
     },
 
-    // TODO(sorvell): multiple side-effects could call autoGo 
-    // during one micro-task, use a job to have only one action 
+    // TODO(sorvell): multiple side-effects could call autoGo
+    // during one micro-task, use a job to have only one action
     // occur
     autoGo: function() {
       if (this.auto) {
@@ -317,7 +378,26 @@ element.
       args.callback = this.receive.bind(this);
       args.url = this.url;
       args.method = this.method;
-      return args.url && this.xhr.request(args);
+
+      this.response = this.error = this.progress = null;
+      this.activeRequest = args.url && this.xhr.request(args);
+      if (this.activeRequest) {
+        this.loading = true;
+        var activeRequest = this.activeRequest;
+        // IE < 10 doesn't support progress events.
+        if ('onprogress' in activeRequest) {
+          this.activeRequest.addEventListener(
+              'progress',
+              function(progress) {
+                this.processProgress(progress, activeRequest);
+              }.bind(this), false);
+        } else {
+          this.progress = {
+            lengthComputable: false,
+          }
+        }
+      }
+      return this.activeRequest;
     }
 
   });