sprockets-preload 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9aa6c3e861748967179166f9e5eec2641432f274
+  data.tar.gz: df369157c3ee8cefcda79d361c43fa5f26c5522f
+SHA512:
+  metadata.gz: 724a9ba684c9a94d3ecea83615aa402fe54d7cbaf75df98553c3e306f876910c41b07e6bdbe8dd7d643f312af7ab783e15f1bd63bf6be31a1a889b44718ba795
+  data.tar.gz: be1d272adb7cd4bfa2d77ae4528a04f64ad751c60fe78b5942588988228e7a9719159f5a544e4329c2f5ab417492d284052896b1864124a5b06f8354b6c406b5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'pry'
+gem 'rake'
+gem 'rspec'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Boris Staal
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,136 @@
+# Sprockets::Preload
+
+[![Gem Version](https://badge.fury.io/rb/sprockets-preload.png)](http://badge.fury.io/rb/sprockets-preload)
+[![Build Status](https://travis-ci.org/inossidabile/sprockets-preload.png?branch=master)](https://travis-ci.org/inossidabile/sprockets-preload)
+
+Ever had heavy Javascript assets that were taking a while to download? **Sprockets::Preload** allows you to preload it using only the directives of **Sprockets**.
+
+Show your users nice loading bar instead of just white loading screen!
+
+## Usage
+
+Imagine that you are riding on Rails and have the following `application.js` where `jquery`, `jquery-ui` and `front` (MVC front-end application) take around 500kb compressed altogether:
+
+```javascript
+//= include helpers
+//= include jquery
+//= include jquery-ui
+//= include front
+
+// Starting application
+$ -> Front.start()
+```
+
+Let's make user experience smooth:
+
+1. Add `sprockets-preload` to your `Gemfile` and run `bundle install`
+
+2. Change `//= include` to `//= preload` for the assets you want to detouch:
+
+    ```javascript
+    //= include helpers
+    //= preload jquery
+    //= preload jquery-ui
+    //= preload front
+
+    // Starting application
+    $ -> Front.start()
+    ```
+
+3. Delay initialization to the moment when detouched assets are loaded:
+
+    ```javascript
+    //= include helpers
+    //= preload jquery
+    //= preload jquery-ui
+    //= preload front
+
+    SprocketsPreload.success = function() {
+      // Starting application
+      $ -> Front.start()
+    }
+    ```
+
+4. Track loading and show progress to user
+
+    ```javascript
+    //= include helpers
+    //= preload jquery
+    //= preload jquery-ui
+    //= preload front
+
+    SprocketsPreload.success = function() {
+      // Starting application
+      $ -> Front.start()
+    }
+
+    SprocketsPreload.progress = function(percent) {
+      // User isn't going to see percents at console
+      // but that's just an example after all
+      console.log(percent);
+    }
+    ```
+
+5. **IMPORTANT**: Rails development environment uses stub to ease debugging. Thus while things keep working, assets don't really get detouched. To force production-grade loading (just to make sure things work fine) add `//= preload!` to your manifest:
+
+    ```javascript
+    //= preload!
+    //= include helpers
+    //= preload jquery
+    //= preload jquery-ui
+    //= preload front
+
+    SprocketsPreload.success = function() {
+      // Starting application
+      $ -> Front.start()
+    }
+
+    SprocketsPreload.progress = function(percent) {
+      // User isn't going to see percents at console
+      // but that's just an example after all
+      console.log(percent);
+    }
+    ```
+
+    Make sure to remove `//= preload!` when your tests are done.
+
+## Caching options
+
+To make loading progress tracking smooth and cache manually controllable, **Sprockets::Preload** uses `localStorage` to cache assets (it falls back to default browser cache automatically). **Sprockets** provides digests and logic-aware dependency system that work much better and much more predictable than more common default HTTP caching.
+
+That's said – you really want to keep `localStorage` strategy in the vast majority of cases. If however for some reason you still want to make it use default browser cache, set `SprocketsPreload.localStorage` to `false` like this:
+
+```javascript
+//= preload!
+//= include helpers
+//= preload jquery
+//= preload jquery-ui
+//= preload front
+
+SprocketsPreload.localStorage = false;
+
+SprocketsPreload.success = function() {
+  // Starting application
+  $ -> Front.start()
+}
+
+SprocketsPreload.progress = function(percent) {
+  // User isn't going to see percents at console
+  // but that's just an example after all
+  console.log(percent);
+}
+```
+
+**Note** that default caching strategy will still try to emulate loading progress tracking but it works MUCH worse.
+
+## Compatibility
+
+**Sprockets::Preload** does not depend on Rails. However it has proper rail-ties and is fully-functional on Rails out of box. If you want to use it outside of Rails with clean **Sprockets** – see `lib/sprockets/preload/engine.rb` for required initialization settings.
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/assets/sprockets/preload/assets.js.erb

@@ -0,0 +1,10 @@
+<%
+
+# we have to check all base-level assets to find out what exactly is preloading 
+Sprockets::Preload.each_logical_path do |logical_path, environment|
+  Sprockets::Preload.collect(environment, logical_path).each do |dependency|
+    require_asset dependency
+  end
+end
+
+%>

data/assets/sprockets/preload/load.coffee.erb

@@ -0,0 +1,121 @@
+#= depend_on_asset sprockets/preload/assets
+
+@SprocketsPreload =
+
+  onload: (callback) ->
+    @localStorage = true unless @localStorage?
+
+    return callback() if document && document.readyState is "complete"
+    
+    if window.addEventListener
+      window.addEventListener "DOMContentLoaded", callback, false
+    else
+      window.attachEvent "onload", handler if window.attachEvent
+
+  #
+  # Dispatches events through `document`
+  #
+  trigger: (name, data) ->
+    if document.createEvent
+      event = document.createEvent('Events')
+      event.data = data if data
+      event.initEvent name, true, true
+      document.dispatchEvent event
+    else if document.createEventObject
+      event = document.createEventObject()
+      event.data = data if data
+      document.fireEvent "on" + name, event
+
+  #
+  # Happens from time to time during downloading (but only when localStorage caching enabled)
+  #
+  triggerProgress: (percent) ->
+    @progress? percent
+    @trigger 'sprockets:progress', percent: percent
+
+  #
+  # Happens when preloading assets are loaded
+  #
+  triggerSuccess: ->
+    @success?()
+    @trigger 'sprockets:loaded'
+
+  #
+  # Creates `script` tag with given attributes and adds it to head
+  #
+  inject: (attributes={}) ->
+    node = document.createElement "script"
+    node[k] = v for k, v of attributes
+    document.getElementsByTagName("head")[0].appendChild node
+
+  #
+  # Loads asset using localStorage as a manual cache
+  #
+  loadCached: (url, version, size) ->
+    attempt = localStorage['sprockets-preload']
+    attempt = JSON.parse(attempt) if attempt
+
+    if attempt?.version == version
+      @inject defer: true, text: attempt.source
+      @triggerProgress 100
+      @triggerSuccess 100
+    else
+      xhr = @_ajax 'GET', url, (xhr) =>
+        clearInterval poller
+        localStorage['sprockets-preload'] = JSON.stringify
+          version: version
+          source: xhr.responseText
+
+        @inject defer: true, text: xhr.responseText
+        @triggerProgress 100
+        @triggerSuccess()
+
+      if size > 0
+        poller = setInterval (=>
+          @triggerProgress Math.round(xhr.responseText.length / size * 100 * 100) / 100
+        ), 100
+
+  #
+  # Loads asset using built-in browser caching
+  #
+  loadSimple: (url) ->
+    script = document.createElement "script"
+    done   = false
+    self   = @
+
+    proceed = ->
+      if !done && (!@readyState? || @readyState == "loaded" || @readyState == "complete")
+        done = true; script.onload = script.onreadystatechange = null
+        self.triggerSuccess()
+
+    @inject src: url, onload: proceed, onreadystatechange: proceed
+
+  #
+  # Starring custom XHR wrapper
+  #
+  _ajax: (method, url, callback) ->
+    if window.XMLHttpRequest
+      xhr = new XMLHttpRequest
+    else
+      xhr = new ActiveXObject 'Microsoft.XMLHTTP'
+
+    xhr.onreadystatechange = -> callback?(xhr) if xhr.readyState > 3
+    xhr.open method, url, 1
+    xhr.send()
+
+    xhr
+
+@SprocketsPreload.onload ->
+  if SprocketsPreload.inline
+    delete localStorage['sprockets-preload'] if window.localStorage?
+    SprocketsPreload.triggerProgress 100
+    SprocketsPreload.triggerSuccess()
+  else if SprocketsPreload.localStorage && window.localStorage
+    SprocketsPreload.loadCached(
+      <%= javascript_path('sprockets/preload/assets').to_json %>,
+      <%= Sprockets::Preload['sprockets/preload/assets'].digest.to_json %>,
+      <%= Sprockets::Preload['sprockets/preload/assets'].length.to_json %>
+    )
+  else
+    delete localStorage['sprockets-preload'] if window.localStorage?
+    SprocketsPreload.loadSimple(<%= javascript_path('sprockets/preload/assets').to_json %>)

data/lib/sprockets/preload/context.rb

@@ -0,0 +1,19 @@
+#
+# Extends asset context with storage for assets to preload
+#
+module Sprockets
+  module Preload
+    module Context
+      def self.included(mod)
+        mod.instance_eval do
+          attr_accessor :_assets_to_preload
+          attr_accessor :_force_preload
+        end
+      end
+
+      def preload?
+        _force_preload || !Sprockets::Preload.inline
+      end
+    end
+  end
+end

data/lib/sprockets/preload/directive_processor.rb

@@ -0,0 +1,28 @@
+#
+# Adds `#= preload {path}` and `#= preload!` directives
+#
+module Sprockets
+  module Preload
+    module DirectiveProcessor
+      def process_preload_directive(path)
+        if context.content_type != 'application/javascript'
+          process_require_directive path
+        else 
+          unless context._assets_to_preload
+            process_require_directive 'sprockets/preload/load'
+            context._assets_to_preload = []
+          end
+
+          context.require_asset path
+          context.stub_asset path if context.preload?
+
+          context._assets_to_preload.push path
+        end
+      end
+
+      define_method :"process_preload!_directive" do
+        context._force_preload = true
+      end
+    end
+  end
+end

data/lib/sprockets/preload/engine.rb

@@ -0,0 +1,16 @@
+#
+# Defines Rails-based entries for Sprockets instance and the list of base-level assets
+#
+module Sprockets
+  module Preload
+    class Engine < ::Rails::Engine
+      initializer "sprockets.preload" do |app|
+        Sprockets::Preload.inline      = ::Rails.env.development?
+        Sprockets::Preload.environment = app.assets
+        Sprockets::Preload.precompiles = app.config.assets.precompile
+
+        app.config.assets.precompile += ['sprockets/preload/assets', 'sprockets/preload/load']
+      end
+    end
+  end
+end

data/lib/sprockets/preload/errors.rb

@@ -0,0 +1,5 @@
+module Sprockets
+  module Preload
+    class CircularPreloadError < StandardError; end
+  end
+end

data/lib/sprockets/preload/version.rb

@@ -0,0 +1,5 @@
+module Sprockets
+  module Preload
+    VERSION = "0.0.1"
+  end
+end

data/lib/sprockets/preload.rb

@@ -0,0 +1,87 @@
+require 'active_support/all'
+require 'sprockets'
+require 'sprockets/preload/directive_processor'
+require 'sprockets/preload/context'
+require 'sprockets/preload/version'
+require 'sprockets/preload/errors'
+require 'sprockets/preload/engine' if defined?(Rails)
+
+Sprockets::DirectiveProcessor.send :include, Sprockets::Preload::DirectiveProcessor
+Sprockets::Context.send :include, Sprockets::Preload::Context
+
+Sprockets.append_path File.expand_path('../../../assets', __FILE__)
+
+# Pass in current environment condition to mark if loading should be stubbed
+Sprockets.register_postprocessor 'application/javascript', :preload do |context, data|
+  if context._assets_to_preload
+    data << "SprocketsPreload.inline = true;" unless context.preload?
+  end
+
+  data
+end
+
+module Sprockets
+  module Preload
+    class <<self
+      attr_accessor :inline
+      attr_accessor :environment
+      attr_accessor :precompiles
+    end
+
+    #
+    # Forks circular calls protection to allow cross-tree assets interactions
+    #
+    def self.[](path)
+      calls = Thread.current[:sprockets_circular_calls]
+      Thread.current[:sprockets_circular_calls] = Set.new
+      environment[path]
+    ensure
+      Thread.current[:sprockets_circular_calls] = calls
+    end
+
+    #
+    # Iterates through all JS base-level assets of an application
+    #
+    def self.each_logical_path(&block)
+      paths = environment.each_logical_path(*precompiles).to_a +
+        precompiles.flatten.select{ |fn| Pathname.new(fn).absolute? if fn.is_a?(String) }
+
+      paths.each do |path|
+        yield(path, environment) if environment.content_type_of(path) == 'application/javascript'
+      end
+    end
+
+    #
+    # Recursively collects #= preload directives from given logical path
+    #
+    def self.collect(environment, logical_path)
+      pathname = environment.resolve logical_path
+      context  = environment.context_class.new(environment, logical_path, pathname)
+      template = Sprockets::DirectiveProcessor.new(pathname.to_s)
+      template.render(context, {})
+
+      to_preload = context._assets_to_preload || []
+
+      # Files marked for preloading should not have nested preload directives
+      to_preload.each do |dependency|
+        nesteds = collect(environment, dependency)
+        if nesteds.length > 0
+          raise CircularPreloadError.new("Circular preloading detected: #{dependency} -> #{nesteds.join(',')}")
+        end
+      end
+
+      # Going deeper
+      dependencies = context._required_paths.map do |dependency|
+        environment.attributes_for(dependency).logical_path
+      end
+
+      dependencies -= context._stubbed_assets.to_a
+
+      dependencies.each do |dependency|
+        to_preload += collect(environment, dependency)
+      end
+
+      to_preload
+    end
+  end
+end

data/spec/helpers/assets/circular/circular.js

@@ -0,0 +1 @@
+//= preload circular/test1

data/spec/helpers/assets/circular/test1.js

@@ -0,0 +1,2 @@
+//= preload circular/test2
+test1

data/spec/helpers/assets/circular/test2.coffee

@@ -0,0 +1 @@
+test2

data/spec/helpers/assets/direct/direct.js

@@ -0,0 +1,3 @@
+//= preload direct/test1
+//= preload direct/test2
+//= require_tree ./

data/spec/helpers/assets/direct/test1.js

@@ -0,0 +1 @@
+test1

data/spec/helpers/assets/direct/test2.js

@@ -0,0 +1 @@
+test2

data/spec/helpers/assets/forced/forced.js

@@ -0,0 +1,4 @@
+//= preload!
+//= preload forced/test1
+//= preload forced/test2
+//= require_tree ./

data/spec/helpers/assets/forced/test1.js

@@ -0,0 +1 @@
+test1

data/spec/helpers/assets/forced/test2.js

@@ -0,0 +1 @@
+test2

data/spec/helpers/assets/nested/nested.js

@@ -0,0 +1 @@
+//= require nested/test1

data/spec/helpers/assets/nested/test1.js

@@ -0,0 +1,2 @@
+//= preload nested/test2
+test1

data/spec/helpers/assets/nested/test2.js

@@ -0,0 +1 @@
+test2

data/spec/helpers/boot.rb

@@ -0,0 +1,45 @@
+require 'bundler/setup'
+
+Bundler.require
+
+Sprockets::Context.class_eval do
+  def asset_path(path, options={})
+    "/#{path}"
+  end
+end
+
+Sprockets::Preload.precompiles = []
+Sprockets.append_path File.expand_path('../assets', __FILE__)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random:59695'
+
+  config.before(:each) do
+    Sprockets::Preload.environment = Sprockets::Environment.new
+  end
+end
+
+shared_context "inlined", inline: true do
+  before(:all) do
+    @inline_condition = Sprockets::Preload.inline
+    Sprockets::Preload.inline = true
+  end
+
+  after(:all) do
+    Sprockets::Preload.inline = @inline_condition
+  end
+end
+
+shared_context "detouched", inline: false do
+  before(:all) do
+    @inline_condition = Sprockets::Preload.inline
+    Sprockets::Preload.inline = false
+  end
+
+  after(:all) do
+    Sprockets::Preload.inline = @inline_condition
+  end
+end

data/spec/integrational/circular_spec.rb

@@ -0,0 +1,17 @@
+require 'helpers/boot'
+
+describe "Circular dependency" do
+  before(:all) do
+    Sprockets::Preload.precompiles += ["circular/circular.js"]
+  end
+
+  after(:all) do
+    Sprockets::Preload.precompiles -= ["circular/circular.js"]
+  end
+
+  it "throws" do
+    expect{
+      Sprockets::Preload.environment['sprockets/preload/assets']
+    }.to raise_error Sprockets::Preload::CircularPreloadError
+  end
+end

data/spec/integrational/direct_spec.rb

@@ -0,0 +1,29 @@
+require 'helpers/boot'
+
+describe "Direct dependency" do
+  before(:all) do
+    Sprockets::Preload.precompiles += ["direct/direct.js"]
+  end
+
+  after(:all) do
+    Sprockets::Preload.precompiles -= ["direct/direct.js"]
+  end
+
+  it "serves detouched" do
+    Sprockets::Preload.environment['sprockets/preload/assets'].source.should == "test1\n;\ntest2\n;\n\n"
+  end
+
+  context "inlined", inline: true do
+    it "keeps inlines" do
+      Sprockets::Preload.environment['direct/direct'].source.should include("test1", "test2")
+      Sprockets::Preload.environment['direct/direct'].source.should include("SprocketsPreload.inline = true")
+    end
+  end
+
+  context "detouched", inline: false do
+    it "keeps inlines" do
+      Sprockets::Preload.environment['direct/direct'].source.should_not include("test1", "test2")
+      Sprockets::Preload.environment['direct/direct'].source.should_not include("SprocketsPreload.inline = true")
+    end
+  end
+end

data/spec/integrational/forced_spec.rb

@@ -0,0 +1,29 @@
+require 'helpers/boot'
+
+describe "Direct dependency" do
+  before(:all) do
+    Sprockets::Preload.precompiles += ["forced/forced.js"]
+  end
+
+  after(:all) do
+    Sprockets::Preload.precompiles -= ["forced/forced.js"]
+  end
+
+  it "serves detouched" do
+    Sprockets::Preload.environment['sprockets/preload/assets'].source.should == "test1\n;\ntest2\n;\n\n"
+  end
+
+  context "inlined", inline: true do
+    it "keeps inlines" do
+      Sprockets::Preload.environment['forced/forced'].source.should_not include("test1", "test2")
+      Sprockets::Preload.environment['forced/forced'].source.should_not include("SprocketsPreload.inline = true")
+    end
+  end
+
+  context "detouched", inline: false do
+    it "keeps inlines" do
+      Sprockets::Preload.environment['forced/forced'].source.should_not include("test1", "test2")
+      Sprockets::Preload.environment['forced/forced'].source.should_not include("SprocketsPreload.inline = true")
+    end
+  end
+end

data/spec/integrational/nested_spec.rb

@@ -0,0 +1,30 @@
+require 'helpers/boot'
+
+describe "Nested dependency" do
+  before(:all) do
+    Sprockets::Preload.precompiles += ["nested/nested.js"]
+  end
+
+  after(:all) do
+    Sprockets::Preload.precompiles -= ["nested/nested.js"]
+  end
+
+  it "serves detouched" do
+    Sprockets::Preload.environment['sprockets/preload/assets'].source.should == "test2\n;\n\n"
+  end
+
+  context "inlined", inline: true do
+    it "keeps inlines" do
+      Sprockets::Preload.environment['nested/nested'].source.should include("test1", "test2")
+      Sprockets::Preload.environment['nested/nested'].source.should include("SprocketsPreload.inline = true")
+    end
+  end
+
+  context "detouched", inline: false do
+    it "keeps inlines" do
+      Sprockets::Preload.environment['nested/nested'].source.should include("test1")
+      Sprockets::Preload.environment['nested/nested'].source.should_not include("test2")
+      Sprockets::Preload.environment['nested/nested'].source.should_not include("SprocketsPreload.inline = true")
+    end
+  end
+end

data/sprockets-preload.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sprockets/preload/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sprockets-preload"
+  spec.version       = Sprockets::Preload::VERSION
+  spec.authors       = ["Boris Staal"]
+  spec.email         = ["boris@staal.io"]
+  spec.description   = %q{Macros-based JS preloader for Sprockets}
+  spec.summary       = %q{
+    The gem extends Sprockets with helpers allowing you to
+    controllably load huge JS assets with the support of
+    progress tracking and localStorage caching.
+  }
+  spec.homepage      = "https://github.com/joosy/sprockets-preload"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sprockets"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "coffee-script"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: sprockets-preload
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Boris Staal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coffee-script
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Macros-based JS preloader for Sprockets
+email:
+- boris@staal.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- assets/sprockets/preload/assets.js.erb
+- assets/sprockets/preload/load.coffee.erb
+- lib/sprockets/preload.rb
+- lib/sprockets/preload/context.rb
+- lib/sprockets/preload/directive_processor.rb
+- lib/sprockets/preload/engine.rb
+- lib/sprockets/preload/errors.rb
+- lib/sprockets/preload/version.rb
+- spec/helpers/assets/circular/circular.js
+- spec/helpers/assets/circular/test1.js
+- spec/helpers/assets/circular/test2.coffee
+- spec/helpers/assets/direct/direct.js
+- spec/helpers/assets/direct/test1.js
+- spec/helpers/assets/direct/test2.js
+- spec/helpers/assets/forced/forced.js
+- spec/helpers/assets/forced/test1.js
+- spec/helpers/assets/forced/test2.js
+- spec/helpers/assets/nested/nested.js
+- spec/helpers/assets/nested/test1.js
+- spec/helpers/assets/nested/test2.js
+- spec/helpers/boot.rb
+- spec/integrational/circular_spec.rb
+- spec/integrational/direct_spec.rb
+- spec/integrational/forced_spec.rb
+- spec/integrational/nested_spec.rb
+- sprockets-preload.gemspec
+homepage: https://github.com/joosy/sprockets-preload
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: The gem extends Sprockets with helpers allowing you to controllably load
+  huge JS assets with the support of progress tracking and localStorage caching.
+test_files:
+- spec/helpers/assets/circular/circular.js
+- spec/helpers/assets/circular/test1.js
+- spec/helpers/assets/circular/test2.coffee
+- spec/helpers/assets/direct/direct.js
+- spec/helpers/assets/direct/test1.js
+- spec/helpers/assets/direct/test2.js
+- spec/helpers/assets/forced/forced.js
+- spec/helpers/assets/forced/test1.js
+- spec/helpers/assets/forced/test2.js
+- spec/helpers/assets/nested/nested.js
+- spec/helpers/assets/nested/test1.js
+- spec/helpers/assets/nested/test2.js
+- spec/helpers/boot.rb
+- spec/integrational/circular_spec.rb
+- spec/integrational/direct_spec.rb
+- spec/integrational/forced_spec.rb
+- spec/integrational/nested_spec.rb