polymer-iron-rails 1.0.0.pre.rc.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0646b43a48ac4cfcdea8a66362e5062d65488915
+  data.tar.gz: 6bde260f468a95090c3a6c06b4508718d0d80596
+SHA512:
+  metadata.gz: a9910152c9ee2a6ea9017f9bcb3d0b2e7acd73f744061d3e9cafcec6e62fae37aaf83659913fa2281157d9ddcdd67a8fb8d1e677d60c1424cd8561820c26a552
+  data.tar.gz: b31e46226599202bfe61af0c1684ee671a0c35caff77625b87cb924129d6e8e222fd547c32b1b8f1d958ab0798333c4da824a3b5fdc35067840d2aae07a658f8

data/README.md

@@ -0,0 +1,57 @@
+# PolymerIronRails
+
+Polymer Iron elements are a set of utility elements including general-purpose UI elements (such as icons, layout elements,
+and toolbars), as well as non-UI elements providing features like AJAX, signaling and storage.
+
+Polymer-iron-rails gem brings polymer iron web components into your Rails project.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'polymer-iron-rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install polymer-iron-rails
+
+## Getting started
+
+In order to use Polymer iron elements you need to have
+`polymer` installed in your project. Use [polymer-rails](https://github.com/alchapone/polymer-rails) gem for adding `polymer` to your Rails application.
+
+```ruby
+gem 'polymer-rails'
+gem 'polymer-iron-rails'
+```
+
+After running `bundle install` require needed iron elements into your `application.html` manifest file.
+
+    //= require polymer/polymer
+    //= require iron-ajax/iron-ajax
+    //= require iron-input/iron-input
+    .....
+    //= require iron-signals/iron-signals
+
+Each component should be required only once. Thus if you've already required component that has dependencies, you don't need
+to explicitly require any of dependencies, otherwise it will raise exception.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/polymer-iron-rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/assets/components/hydrolysis/API.md

@@ -0,0 +1,360 @@
+## Objects
+<dl>
+<dt><a href="#hydrolysis">hydrolysis</a> : <code>object</code></dt>
+<dd><p>Static analysis for Polymer.</p>
+</dd>
+</dl>
+## Functions
+<dl>
+<dt><a href="#isSiblingOrAunt">isSiblingOrAunt()</a> ⇒ <code>boolean</code></dt>
+<dd><p>Returns true if <code>patha</code> is a sibling or aunt of <code>pathb</code>.</p>
+</dd>
+<dt><a href="#redirectSibling">redirectSibling()</a> ⇒ <code>string</code></dt>
+<dd><p>Change <code>localPath</code> from a sibling of <code>basePath</code> to be a child of
+<code>basePath</code> joined with <code>redirect</code>.</p>
+</dd>
+</dl>
+<a name="hydrolysis"></a>
+## hydrolysis : <code>object</code>
+Static analysis for Polymer.
+
+**Kind**: global namespace  
+
+* [hydrolysis](#hydrolysis) : <code>object</code>
+  * [.Analyzer](#hydrolysis.Analyzer)
+    * [new Analyzer(attachAST, [loader])](#new_hydrolysis.Analyzer_new)
+    * _instance_
+      * [.elements](#hydrolysis.Analyzer#elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
+      * [.elementsByTagName](#hydrolysis.Analyzer#elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
+      * [.features](#hydrolysis.Analyzer#features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
+      * [.behaviors](#hydrolysis.Analyzer#behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
+      * [.html](#hydrolysis.Analyzer#html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
+      * [.parsedDocuments](#hydrolysis.Analyzer#parsedDocuments) : <code>Object</code>
+      * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer#_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
+      * [.metadataTree(href)](#hydrolysis.Analyzer#metadataTree) ⇒ <code>Promise</code>
+      * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer#nodeWalkDocuments) ⇒ <code>Object</code>
+      * [.annotate()](#hydrolysis.Analyzer#annotate)
+      * [.clean()](#hydrolysis.Analyzer#clean)
+    * _static_
+      * [.analyze(href, [options])](#hydrolysis.Analyzer.analyze) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
+  * [.FileLoader](#hydrolysis.FileLoader)
+    * [new FileLoader()](#new_hydrolysis.FileLoader_new)
+    * [.addResolver(resolver)](#hydrolysis.FileLoader#addResolver)
+    * [.request(url)](#hydrolysis.FileLoader#request) ⇒ <code>Promise.&lt;string&gt;</code>
+  * [.FSResolver](#hydrolysis.FSResolver)
+    * [new FSResolver(config)](#new_hydrolysis.FSResolver_new)
+  * [.NoopResolver](#hydrolysis.NoopResolver)
+    * [new NoopResolver(config)](#new_hydrolysis.NoopResolver_new)
+    * [.accept(uri, deferred)](#hydrolysis.NoopResolver#accept) ⇒ <code>boolean</code>
+  * [.XHRResolver](#hydrolysis.XHRResolver)
+    * [new XHRResolver(config)](#new_hydrolysis.XHRResolver_new)
+  * [.DocumentAST](#hydrolysis.DocumentAST) : <code>Object</code>
+  * [.ElementDescriptor](#hydrolysis.ElementDescriptor) : <code>Object</code>
+  * [.FeatureDescriptor](#hydrolysis.FeatureDescriptor) : <code>Object</code>
+  * [.BehaviorDescriptor](#hydrolysis.BehaviorDescriptor) : <code>Object</code>
+  * [.DocumentDescriptor](#hydrolysis.DocumentDescriptor) : <code>Object</code>
+  * [.AnalyzedDocument](#hydrolysis.AnalyzedDocument) : <code>Object</code>
+  * [.LoadOptions](#hydrolysis.LoadOptions) : <code>Object</code>
+  * [.Resolver](#hydrolysis.Resolver) : <code>Object</code>
+
+<a name="hydrolysis.Analyzer"></a>
+### hydrolysis.Analyzer
+**Kind**: static class of <code>[hydrolysis](#hydrolysis)</code>  
+
+* [.Analyzer](#hydrolysis.Analyzer)
+  * [new Analyzer(attachAST, [loader])](#new_hydrolysis.Analyzer_new)
+  * _instance_
+    * [.elements](#hydrolysis.Analyzer#elements) : <code>Array.&lt;ElementDescriptor&gt;</code>
+    * [.elementsByTagName](#hydrolysis.Analyzer#elementsByTagName) : <code>Object.&lt;string, ElementDescriptor&gt;</code>
+    * [.features](#hydrolysis.Analyzer#features) : <code>Array.&lt;FeatureDescriptor&gt;</code>
+    * [.behaviors](#hydrolysis.Analyzer#behaviors) : <code>Array.&lt;BehaviorDescriptor&gt;</code>
+    * [.html](#hydrolysis.Analyzer#html) : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
+    * [.parsedDocuments](#hydrolysis.Analyzer#parsedDocuments) : <code>Object</code>
+    * [._getDependencies(href, [found], [transitive])](#hydrolysis.Analyzer#_getDependencies) ⇒ <code>Array.&lt;string&gt;</code>
+    * [.metadataTree(href)](#hydrolysis.Analyzer#metadataTree) ⇒ <code>Promise</code>
+    * [.nodeWalkDocuments(predicate)](#hydrolysis.Analyzer#nodeWalkDocuments) ⇒ <code>Object</code>
+    * [.annotate()](#hydrolysis.Analyzer#annotate)
+    * [.clean()](#hydrolysis.Analyzer#clean)
+  * _static_
+    * [.analyze(href, [options])](#hydrolysis.Analyzer.analyze) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
+
+<a name="new_hydrolysis.Analyzer_new"></a>
+#### new Analyzer(attachAST, [loader])
+A database of Polymer metadata defined in HTML
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| attachAST | <code>boolean</code> | If true, attach a parse5 compliant AST |
+| [loader] | <code>FileLoader</code> | An optional `FileLoader` used to load external                              resources |
+
+<a name="hydrolysis.Analyzer#elements"></a>
+#### analyzer.elements : <code>Array.&lt;ElementDescriptor&gt;</code>
+A list of all elements the `Analyzer` has metadata for.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#elementsByTagName"></a>
+#### analyzer.elementsByTagName : <code>Object.&lt;string, ElementDescriptor&gt;</code>
+A view into `elements`, keyed by tag name.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#features"></a>
+#### analyzer.features : <code>Array.&lt;FeatureDescriptor&gt;</code>
+A list of API features added to `Polymer.Base` encountered by the
+analyzer.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#behaviors"></a>
+#### analyzer.behaviors : <code>Array.&lt;BehaviorDescriptor&gt;</code>
+The behaviors collected by the analysis pass.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#html"></a>
+#### analyzer.html : <code>Object.&lt;string, AnalyzedDocument&gt;</code>
+A map, keyed by absolute path, of Document metadata.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#parsedDocuments"></a>
+#### analyzer.parsedDocuments : <code>Object</code>
+A map, keyed by path, of HTML document ASTs.
+
+**Kind**: instance property of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#_getDependencies"></a>
+#### analyzer._getDependencies(href, [found], [transitive]) ⇒ <code>Array.&lt;string&gt;</code>
+List all the html dependencies for the document at `href`.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+**Returns**: <code>Array.&lt;string&gt;</code> - A list of all the html dependencies.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| href | <code>string</code> | The href to get dependencies for. |
+| [found] | <code>Object.&lt;string, boolean&gt;</code> | An object keyed by URL of the     already resolved dependencies. |
+| [transitive] | <code>boolean</code> | Whether to load transitive     dependencies. Defaults to true. |
+
+<a name="hydrolysis.Analyzer#metadataTree"></a>
+#### analyzer.metadataTree(href) ⇒ <code>Promise</code>
+Returns a promise that resolves to a POJO representation of the import
+tree, in a format that maintains the ordering of the HTML imports spec.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| href | <code>string</code> | the import to get metadata for. |
+
+<a name="hydrolysis.Analyzer#nodeWalkDocuments"></a>
+#### analyzer.nodeWalkDocuments(predicate) ⇒ <code>Object</code>
+Calls `dom5.nodeWalk` on each document that `Anayzler` has laoded.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| predicate | <code>Object</code> | A dom5 predicate. |
+
+<a name="hydrolysis.Analyzer#annotate"></a>
+#### analyzer.annotate()
+Annotates all loaded metadata with its documentation.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer#clean"></a>
+#### analyzer.clean()
+Removes redundant properties from the collected descriptors.
+
+**Kind**: instance method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+<a name="hydrolysis.Analyzer.analyze"></a>
+#### Analyzer.analyze(href, [options]) ⇒ <code>Promise.&lt;Analyzer&gt;</code>
+Shorthand for transitively loading and processing all imports beginning at
+`href`.
+
+In order to properly filter paths, `href` _must_ be an absolute URI.
+
+**Kind**: static method of <code>[Analyzer](#hydrolysis.Analyzer)</code>  
+**Returns**: <code>Promise.&lt;Analyzer&gt;</code> - A promise that will resolve once `href` and its
+    dependencies have been loaded and analyzed.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| href | <code>string</code> | The root import to begin loading from. |
+| [options] | <code>LoadOptions</code> | Any additional options for the load. |
+
+<a name="hydrolysis.FileLoader"></a>
+### hydrolysis.FileLoader
+**Kind**: static class of <code>[hydrolysis](#hydrolysis)</code>  
+
+* [.FileLoader](#hydrolysis.FileLoader)
+  * [new FileLoader()](#new_hydrolysis.FileLoader_new)
+  * [.addResolver(resolver)](#hydrolysis.FileLoader#addResolver)
+  * [.request(url)](#hydrolysis.FileLoader#request) ⇒ <code>Promise.&lt;string&gt;</code>
+
+<a name="new_hydrolysis.FileLoader_new"></a>
+#### new FileLoader()
+A FileLoader lets you resolve URLs with a set of potential resolvers.
+
+<a name="hydrolysis.FileLoader#addResolver"></a>
+#### fileLoader.addResolver(resolver)
+Add an instance of a Resolver class to the list of url resolvers
+
+Ordering of resolvers is most to least recently added
+The first resolver to "accept" the url wins.
+
+**Kind**: instance method of <code>[FileLoader](#hydrolysis.FileLoader)</code>  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| resolver | <code>Resolver</code> | The resolver to add. |
+
+<a name="hydrolysis.FileLoader#request"></a>
+#### fileLoader.request(url) ⇒ <code>Promise.&lt;string&gt;</code>
+Return a promise for an absolute url
+
+Url requests are deduplicated by the loader, returning the same Promise for
+identical urls
+
+**Kind**: instance method of <code>[FileLoader](#hydrolysis.FileLoader)</code>  
+**Returns**: <code>Promise.&lt;string&gt;</code> - A promise that resolves to the contents of the URL.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| url | <code>string</code> | The absolute url to request. |
+
+<a name="hydrolysis.FSResolver"></a>
+### hydrolysis.FSResolver
+**Kind**: static class of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="new_hydrolysis.FSResolver_new"></a>
+#### new FSResolver(config)
+Resolves requests via the file system.
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| config | <code>Object</code> | configuration options. |
+| config.host | <code>string</code> | Hostname to match for absolute urls.     Matches "/" by default |
+| config.basePath | <code>string</code> | Prefix directory for components in url.     Defaults to "/". |
+| config.root | <code>string</code> | Filesystem root to search. Defaults to the     current working directory. |
+| config.redirect | <code>string</code> | Where to redirect lookups to siblings. |
+
+<a name="hydrolysis.NoopResolver"></a>
+### hydrolysis.NoopResolver
+**Kind**: static class of <code>[hydrolysis](#hydrolysis)</code>  
+
+* [.NoopResolver](#hydrolysis.NoopResolver)
+  * [new NoopResolver(config)](#new_hydrolysis.NoopResolver_new)
+  * [.accept(uri, deferred)](#hydrolysis.NoopResolver#accept) ⇒ <code>boolean</code>
+
+<a name="new_hydrolysis.NoopResolver_new"></a>
+#### new NoopResolver(config)
+A resolver that resolves to null any uri matching config.
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| config | <code>string</code> | The url to `accept`. |
+
+<a name="hydrolysis.NoopResolver#accept"></a>
+#### noopResolver.accept(uri, deferred) ⇒ <code>boolean</code>
+**Kind**: instance method of <code>[NoopResolver](#hydrolysis.NoopResolver)</code>  
+**Returns**: <code>boolean</code> - Whether the URI is handled by this resolver.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| uri | <code>string</code> | The absolute URI being requested. |
+| deferred | <code>Deferred</code> | The deferred promise that should be resolved if     this resolver handles the URI. |
+
+<a name="hydrolysis.XHRResolver"></a>
+### hydrolysis.XHRResolver
+**Kind**: static class of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="new_hydrolysis.XHRResolver_new"></a>
+#### new XHRResolver(config)
+Construct a resolver that requests resources over XHR.
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| config | <code>Object</code> | configuration arguments. |
+| config.responseType | <code>string</code> | Type of object to be returned by the     XHR. Defaults to 'text', accepts 'document', 'arraybuffer', and 'json'. |
+
+<a name="hydrolysis.DocumentAST"></a>
+### hydrolysis.DocumentAST : <code>Object</code>
+Parse5's representation of a parsed html document
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="hydrolysis.ElementDescriptor"></a>
+### hydrolysis.ElementDescriptor : <code>Object</code>
+The metadata for a single polymer element
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="hydrolysis.FeatureDescriptor"></a>
+### hydrolysis.FeatureDescriptor : <code>Object</code>
+The metadata for a Polymer feature.
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="hydrolysis.BehaviorDescriptor"></a>
+### hydrolysis.BehaviorDescriptor : <code>Object</code>
+The metadata for a Polymer behavior mixin.
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+<a name="hydrolysis.DocumentDescriptor"></a>
+### hydrolysis.DocumentDescriptor : <code>Object</code>
+The metadata for all features and elements defined in one document
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| elements | <code>Array.&lt;ElementDescriptor&gt;</code> | The elements from the document |
+| features | <code>Array.&lt;FeatureDescriptor&gt;</code> | The features from the document |
+| behaviors | <code>Array.&lt;FeatureDescriptor&gt;</code> | The behaviors from the document |
+
+<a name="hydrolysis.AnalyzedDocument"></a>
+### hydrolysis.AnalyzedDocument : <code>Object</code>
+The metadata of an entire HTML document, in promises.
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| href | <code>string</code> | The url of the document. |
+| htmlLoaded | <code>Promise.&lt;ParsedImport&gt;</code> | The parsed representation of     the doc. Use the `ast` property to get the full `parse5` ast |
+| depsLoaded | <code>Promise.&lt;Array.&lt;string&gt;&gt;</code> | Resolves to the list of this     Document's transitive import dependencies |
+| depHrefs | <code>Array.&lt;string&gt;</code> | The direct dependencies of the document. |
+| metadataLoaded | <code>Promise.&lt;DocumentDescriptor&gt;</code> | Resolves to the list of     this Document's import dependencies |
+
+<a name="hydrolysis.LoadOptions"></a>
+### hydrolysis.LoadOptions : <code>Object</code>
+Options for `Analyzer.analzye`
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| noAnnotations | <code>boolean</code> | Whether `annotate()` should be skipped. |
+| clean | <code>boolean</code> | Whether the generated descriptors should be cleaned     of redundant data. |
+| filter | <code>function</code> | A predicate function that     indicates which files should be ignored by the loader. By default all     files not located under the dirname of `href` will be ignored. |
+
+<a name="hydrolysis.Resolver"></a>
+### hydrolysis.Resolver : <code>Object</code>
+An object that knows how to resolve resources.
+
+**Kind**: static typedef of <code>[hydrolysis](#hydrolysis)</code>  
+**Properties**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| accept | <code>function</code> | Attempt to resolve     `deferred` with the contents the specified URL. Returns false if the     Resolver is unable to resolve the URL. |
+
+<a name="isSiblingOrAunt"></a>
+## isSiblingOrAunt() ⇒ <code>boolean</code>
+Returns true if `patha` is a sibling or aunt of `pathb`.
+
+**Kind**: global function  
+<a name="redirectSibling"></a>
+## redirectSibling() ⇒ <code>string</code>
+Change `localPath` from a sibling of `basePath` to be a child of
+`basePath` joined with `redirect`.
+
+**Kind**: global function  

data/app/assets/components/hydrolysis/LICENSE

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

data/app/assets/components/hydrolysis/README.md

@@ -0,0 +1,36 @@
+# hydrolysis
+
+Static anlaysis utilities for polymer.
+
+## Install
+```
+npm install hydrolysis
+```
+
+## Usage
+```js
+var hyd = require('hydrolysis');
+
+hyd.Analyzer.analyze('path-to-polymer-element.html')
+    .then(function(analyzer) {
+      console.log(analyzer.elementsByTagName['my-element'])
+    });
+```
+
+For more detail, see the [API Docs](API.md).
+
+
+## Developing
+You need [wct](https://github.com/Polymer/web-component-tester) to run the tests.
+
+Run a one-off build of the project:
+
+```sh
+npm run build
+```
+
+Or watch the source for changes, and rebuild each time a file is modified:
+
+```sh
+npm run watch
+```

data/app/assets/components/hydrolysis/bower.json

@@ -0,0 +1,19 @@
+{
+  "name": "hydrolysis",
+  "private": true,
+  "ignore": [
+    "lib/",
+    "examples/",
+    "demo/",
+    "test/",
+    ".gitignore",
+    "gulpfile.js",
+    "package.json"
+  ],
+  "devDependencies": {
+    "polymer": "Polymer/polymer#^0.9.0",
+    "webcomponentsjs": "webcomponents/webcomponentsjs#^0.7.0",
+    "web-component-tester": "*"
+  },
+  "version": "1.13.1"
+}

data/app/assets/components/hydrolysis/hydrolysis-analyzer.html

@@ -0,0 +1,114 @@
+<!--
+@license
+Copyright (c) 2015 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="../polymer/polymer.html">
+<link rel="import" href="hydrolysis.html">
+
+<script>
+(function() {
+var hydrolysis = require('hydrolysis');
+
+  Polymer({
+
+    is: 'hydrolysis-analyzer',
+
+    properties: {
+
+      /**
+       * The URL to an import that declares (or transitively imports) the
+       * elements that you wish to see analyzed.
+       *
+       * If the URL is relative, it will be resolved relative to the master
+       * document.
+       *
+       * If you change this value after the `<hydrolysis-analyzer>` has been
+       * instantiated, you must call `analyze()`.
+       */
+      src: {
+        type: String,
+      },
+
+      /**
+       * Whether _all_ dependencies should be loaded and analyzed.
+       *
+       * Turning this on will probably slow down the load process dramatically.
+       */
+      transitive: {
+        type: Boolean,
+      },
+
+      /**
+       * Whether the hydrolysis descriptors should be cleaned of redundant
+       * properties.
+       */
+      clean: {
+        type: Boolean,
+      },
+
+      /** The resultant `Analyzer` object from Hydrolysis. */
+      analyzer: {
+        type:     Object,
+        readOnly: true,
+        notify:   true,
+      },
+
+      /** Whether the analyzer is loading/analyzing resources. */
+      loading: {
+        type:     Boolean,
+        readOnly: true,
+        notify:   true,
+      },
+
+    },
+
+    ready: function() {
+      this.analyze();
+    },
+
+    /**
+     * Begins loading the imports referenced by `src`.
+     *
+     * If you make changes to this element's configuration, you must call this
+     * function to kick off another analysis pass.
+     */
+    analyze: function() {
+      if (!this.src) {
+        return;
+      }
+      // We can implement request cancellation when someone needs it.
+      if (this.loading) {
+        console.error('Analyzer is already loading a document:', this);
+        return;
+      }
+      this._setLoading(true);
+
+      var options = {
+        clean:  this.clean,
+        filter: this.transitive ? function() { return false; } : null,
+        attachAst: true,
+      };
+
+      var baseUri = this.ownerDocument.baseURI;
+      var srcUrl  = new URL(this.src, baseUri).toString();
+      hydrolysis.Analyzer.analyze(srcUrl, options).then(function(analyzer) {
+        this._setLoading(false);
+        this._setAnalyzer(analyzer);
+      }.bind(this))
+      .catch(function(error) {
+        console.error('Failed to load source at:', this.src, error);
+        console.error(error.stack);
+        this._setLoading(false);
+        this._setAnalyzer(null);
+      }.bind(this));
+    },
+
+  });
+
+})();
+</script>

data/app/assets/components/hydrolysis/hydrolysis.html

@@ -0,0 +1,10 @@
+<!--
+@license
+Copyright (c) 2015 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 src="hydrolysis.js"></script>