opal-sprockets 0.4.0.0.10.0.3.0.0 → 0.4.0.0.11.dev.3.1.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c84f0b83233906715c16b29b2fc648fdb853034
-  data.tar.gz: 820fe19a48f66415eb32fce655b70d20521d1d41
+  metadata.gz: 32661426be37d64787c573dce2cc35f816489310
+  data.tar.gz: de0cef69723ae23293fc0b79f812e62cd703ad7a
 SHA512:
-  metadata.gz: 2fa85b43af786cf07d5b01aecbdf3443e6f4f65cd6d65368b2c4fa107f56d66aabf351ad53d03ed8b8bad404f5ffc7b99f9a554868dc7bc3753e830f0fd66259
-  data.tar.gz: a26a2528d7cd58ddf990a5d78c92af469620fcf829785e74e9ef1b5fd0e370e7bc89a7049ef8927d4cbdbeb8a2268eee79ce6cdf5aef17ccea57c2cf324204f0
+  metadata.gz: e2094ff150dbb679d7734cf4df0ee5e10e725cb9eecd64e3d24f66b29fabfe257fa5d6006ff4b1fda306ad43a224f05490b3bba39d5e58dff7256be8fde1f600
+  data.tar.gz: af5c8dab0703e5a7f1ebebaa3f4e80b4f09e80c0f7112f62ba744874f4bca1c3adfb147aa0e592dccdb10363d6aae1889ca7b24a8b79e46d5b2dd6b16917f307

data/Gemfile

@@ -1,6 +1,13 @@
 source 'https://rubygems.org'
 gemspec
 
+opal_path = File.expand_path('../opal')
+if File.exist? opal_path
+  gem 'opal', path: opal_path
+else
+  gem 'opal', github: 'opal/opal'
+end
+
 rack_version      = ENV['RACK_VERSION']
 sprockets_version = ENV['SPROCKETS_VERSION']
 

data/lib/opal/sprockets/environment.rb

@@ -0,0 +1,23 @@
+require 'sprockets'
+require 'opal/sprockets/processor'
+require 'opal/sprockets/erb'
+
+module Opal
+  class Environment < ::Sprockets::Environment
+    def initialize *args
+      super
+      append_opal_paths
+    end
+
+    def use_gem gem_name
+      Opal.use_gem gem_name
+      append_opal_paths
+    end
+
+    private
+
+    def append_opal_paths
+      Opal.paths.each { |p| append_path p }
+    end
+  end
+end

data/lib/opal/sprockets/erb.rb

@@ -0,0 +1,29 @@
+require 'tilt'
+require 'sprockets'
+require 'opal/sprockets/processor'
+
+module Opal
+  module ERB
+    class Processor < ::Opal::Processor
+      def initialize_engine
+        super
+        require_template_library 'opal/erb'
+      end
+
+      def evaluate(context, locals, &block)
+        compiler = Opal::ERB::Compiler.new(@data, context.logical_path.sub(/#{REGEXP_START}templates\//, ''))
+        @data = compiler.prepared_source
+        super
+      end
+    end
+  end
+end
+
+if Sprockets.respond_to? :register_transformer
+  extra_args = [{mime_type: 'application/javascript', silence_deprecation: true}]
+else
+  extra_args = []
+end
+
+Tilt.register 'opalerb', Opal::ERB::Processor
+Sprockets.register_engine '.opalerb', Opal::ERB::Processor, *extra_args

data/lib/opal/sprockets/path_reader.rb

@@ -0,0 +1,36 @@
+module Opal
+  module Sprockets
+
+    class PathReader
+      def initialize(env, context)
+        @env ||= env
+        @context ||= context
+      end
+
+      def read path
+        if path.end_with? '.js'
+          context.depend_on_asset(path)
+          env[path, bundle: true].to_s
+        else
+          context.depend_on(path)
+          File.open(expand(path), 'rb:UTF-8'){|f| f.read}
+        end
+      rescue ::Sprockets::FileNotFound
+        nil
+      end
+
+      def expand path
+        env.resolve(path) or
+          # Sprockets 3 just returns nil for unknown paths
+          raise ::Sprockets::FileNotFound, path.inspect
+      end
+
+      def paths
+        env.paths
+      end
+
+      attr_reader :env, :context
+    end
+
+  end
+end

data/lib/opal/sprockets/processor.rb

@@ -0,0 +1,151 @@
+require 'set'
+require 'tilt/opal'
+require 'sprockets'
+require 'opal/builder'
+require 'opal/sprockets/path_reader'
+require 'opal/sprockets/source_map_server'
+
+$OPAL_SOURCE_MAPS = {}
+
+module Opal
+  # Internal: The Processor class is used to make ruby files (with .rb or .opal
+  #   extensions) available to any sprockets based server. Processor will then
+  #   get passed any ruby source file to build.
+  class Processor < TiltTemplate
+    @@cache_key = nil
+    def self.cache_key
+      @@cache_key ||= ['Opal', Opal::VERSION, Opal::Config.config].to_json.freeze
+    end
+
+    def self.reset_cache_key!
+      @@cache_key = nil
+    end
+
+    def evaluate(context, locals, &block)
+      return super unless context.is_a? ::Sprockets::Context
+
+      @sprockets = sprockets = context.environment
+
+      # In Sprockets 3 logical_path has an odd behavior when the filename is "index"
+      # thus we need to bake our own logical_path
+      filename = context.respond_to?(:filename) ? context.filename : context.pathname.to_s
+      root_path_regexp = Regexp.escape(context.root_path)
+      logical_path = filename.gsub(%r{^#{root_path_regexp}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
+
+      compiler_options = self.compiler_options.merge(file: logical_path)
+
+      # Opal will be loaded immediately to as the runtime redefines some crucial
+      # methods such that need to be implemented as soon as possible:
+      #
+      # E.g. It forwards .toString() to .$to_s() for Opal objects including Array.
+      #      If .$to_s() is not implemented and some other lib is loaded before
+      #      corelib/* .toString results in an `undefined is not a function` error.
+      compiler_options.merge!(requirable: false) if logical_path == 'opal'
+
+      compiler = Compiler.new(data, compiler_options)
+      result = compiler.compile
+
+      process_requires(compiler.requires, context)
+      process_required_trees(compiler.required_trees, context)
+
+      if Opal::Config.source_map_enabled
+        map_contents = compiler.source_map.as_json.to_json
+        ::Opal::SourceMapServer.set_map_cache(sprockets, logical_path, map_contents)
+      end
+
+      result.to_s
+    end
+
+    def self.sprockets_extnames_regexp(sprockets)
+      joined_extnames = (['.js']+sprockets.engines.keys).map { |ext| Regexp.escape(ext) }.join('|')
+      Regexp.new("(#{joined_extnames})*$")
+    end
+
+    def sprockets_extnames_regexp
+      @sprockets_extnames_regexp ||= self.class.sprockets_extnames_regexp(@sprockets)
+    end
+
+    def process_requires(requires, context)
+      requires.each do |required|
+        required = required.to_s.sub(sprockets_extnames_regexp, '')
+        context.require_asset required unless ::Opal::Config.stubbed_files.include? required
+      end
+    end
+
+    # Internal: Add files required with `require_tree` as asset dependencies.
+    #
+    # Mimics (v2) Sprockets::DirectiveProcessor#process_require_tree_directive
+    def process_required_trees(required_trees, context)
+      return if required_trees.empty?
+
+      # This is the root dir of the logical path, we need this because
+      # the compiler gives us the path relative to the file's logical path.
+      dirname = File.dirname(file).gsub(/#{Regexp.escape File.dirname(context.logical_path)}#{REGEXP_END}/, '')
+      dirname = Pathname(dirname)
+
+      required_trees.each do |original_required_tree|
+        required_tree = Pathname(original_required_tree)
+
+        unless required_tree.relative?
+          raise ArgumentError, "require_tree argument must be a relative path: #{required_tree.inspect}"
+        end
+
+        required_tree = dirname.join(file, '..', required_tree)
+
+        unless required_tree.directory?
+          raise ArgumentError, "require_tree argument must be a directory: #{{source: original_required_tree, pathname: required_tree}.inspect}"
+        end
+
+        context.depend_on required_tree.to_s
+
+        environment = context.environment
+
+        processor = ::Sprockets::DirectiveProcessor.new
+        processor.instance_variable_set('@dirname', File.dirname(file))
+        processor.instance_variable_set('@environment', environment)
+        path = processor.__send__(:expand_relative_dirname, :require_tree, original_required_tree)
+        absolute_paths = environment.__send__(:stat_sorted_tree_with_dependencies, path).first.map(&:first)
+
+        absolute_paths.each do |path|
+          path = Pathname(path)
+          pathname = path.relative_path_from(dirname).to_s
+
+          if name.to_s == file  then next
+          elsif path.directory? then context.depend_on(path.to_s)
+          else context.require_asset(pathname)
+          end
+        end
+      end
+    end
+
+    # @deprecated
+    def self.stubbed_files
+      warn "Deprecated: `::Opal::Processor.stubbed_files' is deprecated, use `::Opal::Config.stubbed_files' instead"
+      puts caller(5)
+      ::Opal::Config.stubbed_files
+    end
+
+    # @deprecated
+    def self.stub_file(name)
+      warn "Deprecated: `::Opal::Processor.stub_file' is deprecated, use `::Opal::Config.stubbed_files << #{name.inspect}.to_s' instead"
+      puts caller(5)
+      ::Opal::Config.stubbed_files << name.to_s
+    end
+
+
+    private
+
+    def stubbed_files
+      ::Opal::Config.stubbed_files
+    end
+  end
+end
+
+if Sprockets.respond_to? :register_transformer
+  extra_args = [{mime_type: 'application/javascript', silence_deprecation: true}]
+else
+  extra_args = []
+end
+
+Sprockets.register_engine '.rb',  Opal::Processor, *extra_args
+Sprockets.register_engine '.opal',  Opal::Processor, *extra_args

data/lib/opal/sprockets/server.rb

@@ -0,0 +1,135 @@
+require 'rack'
+require 'opal/source_map'
+require 'sprockets'
+require 'sourcemap'
+require 'erb'
+require 'opal/sprockets/source_map_server'
+require 'opal/sprockets/source_map_header_patch'
+
+module Opal
+  module Sprockets
+    class Server
+      SOURCE_MAPS_PREFIX_PATH = '/__OPAL_SOURCE_MAPS__'
+
+      attr_accessor :debug, :use_index, :index_path, :main, :public_root,
+                    :public_urls, :sprockets, :prefix
+
+      def initialize options = {}
+        @use_index   = true
+        @public_root = nil
+        @public_urls = ['/']
+        @sprockets   = options.fetch(:sprockets, ::Sprockets::Environment.new)
+        @debug       = options.fetch(:debug, true)
+        @prefix      = options.fetch(:prefix, '/assets')
+
+        Opal.paths.each { |p| @sprockets.append_path(p) }
+
+        yield self if block_given?
+        create_app
+      end
+
+      def public_dir=(dir)
+        @public_root = dir
+        @public_urls = ["/"]
+      end
+
+      def source_map=(enabled)
+        Opal::Config.source_map_enabled = enabled
+      end
+
+      def source_map_enabled
+        Opal::Config.source_map_enabled
+      end
+
+      def append_path path
+        @sprockets.append_path path
+      end
+
+      def use_gem gem_name
+        @sprockets.use_gem gem_name
+      end
+
+      def create_app
+        server, sprockets, prefix = self, @sprockets, self.prefix
+        sprockets.logger.level ||= Logger::DEBUG
+        source_map_enabled = self.source_map_enabled
+        if source_map_enabled
+          maps_prefix = SOURCE_MAPS_PREFIX_PATH
+          maps_app = SourceMapServer.new(sprockets, maps_prefix)
+          ::Opal::Sprockets::SourceMapHeaderPatch.inject!(maps_prefix)
+        end
+
+        @app = Rack::Builder.app do
+          not_found = lambda { |env| [404, {}, []] }
+          use Rack::Deflater
+          use Rack::ShowExceptions
+          use Index, server if server.use_index
+          if source_map_enabled
+            map(maps_prefix) do
+              use Rack::ConditionalGet
+              use Rack::ETag
+              run maps_app
+            end
+          end
+          map(prefix)      { run sprockets }
+          run Rack::Static.new(not_found, root: server.public_root, urls: server.public_urls)
+        end
+      end
+
+      def call(env)
+        @app.call env
+      end
+
+      class Index
+
+        def initialize(app, server)
+          @app = app
+          @server = server
+          @index_path = server.index_path
+        end
+
+        def call(env)
+          if %w[/ /index.html].include? env['PATH_INFO']
+            [200, { 'Content-Type' => 'text/html' }, [html]]
+          else
+            @app.call env
+          end
+        end
+
+        # Returns the html content for the root path. Supports ERB
+        def html
+          if @index_path
+            raise "index does not exist: #{@index_path}" unless File.exist?(@index_path)
+            Tilt.new(@index_path).render(self)
+          else
+            raise "Main asset path not configured (set 'main' within Opal::Server.new block)" if @server.main.nil?
+            source
+          end
+        end
+
+        def javascript_include_tag name
+          sprockets = @server.sprockets
+          prefix = @server.prefix
+          debug = @server.debug
+
+          ::Opal::Sprockets.javascript_include_tag(name, sprockets: sprockets, prefix: prefix, debug: debug)
+        end
+
+        def source
+          <<-HTML
+            <!DOCTYPE html>
+            <html>
+            <head>
+              <meta charset="utf-8">
+              <title>Opal Server</title>
+            </head>
+            <body>
+              #{javascript_include_tag @server.main}
+            </body>
+            </html>
+          HTML
+        end
+      end
+    end
+  end
+end

data/lib/opal/sprockets/source_map_header_patch.rb

@@ -0,0 +1,41 @@
+require 'sprockets/server'
+
+module Opal
+  module Sprockets
+    module SourceMapHeaderPatch
+      # Adds the source map header to all sprocket responses for assets
+      # with a .rb or .opal extension in the extension chain.
+      def headers_with_opal_source_maps(env, asset, length)
+        headers_without_opal_source_maps(env, asset, length).tap do |current_headers|
+          if asset.pathname.to_s =~ /\.(rb|opal)\b/
+            base_path = asset.logical_path.gsub('.js', '')
+            current_headers['X-SourceMap'] = "#{::Opal::Sprockets::SourceMapHeaderPatch.prefix}/#{base_path}.map"
+          end
+        end
+      end
+
+      def self.included(base)
+        # Poor man's alias_method_chain :)
+        base.send(:alias_method, :headers_without_opal_source_maps, :headers)
+        base.send(:alias_method, :headers, :headers_with_opal_source_maps)
+      end
+
+      def self.inject!(prefix)
+        self.prefix = prefix
+        unless ::Sprockets::Server.ancestors.include?(self)
+          ::Sprockets::Server.send :include, self
+        end
+      end
+
+      def self.prefix
+        @prefix
+      end
+
+      def self.prefix= val
+        @prefix = val
+      end
+    end
+  end
+end
+
+

data/lib/opal/sprockets/source_map_server.rb

@@ -0,0 +1,115 @@
+module Opal
+  class SourceMapServer
+    # Carelessly taken from Sprockets::Caching (Sprockets v2)
+    class Cache
+      def initialize
+        @cache = {}
+      end
+
+      attr_reader :cache
+
+      def cache_get(key)
+        # `Cache#get(key)` for Memcache
+        if cache.respond_to?(:get)
+          cache.get(key)
+
+        # `Cache#[key]` so `Hash` can be used
+        elsif cache.respond_to?(:[])
+          cache[key]
+
+        # `Cache#read(key)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:read)
+          cache.read(key)
+
+        else
+          nil
+        end
+      end
+
+      def cache_set(key, value)
+        # `Cache#set(key, value)` for Memcache
+        if cache.respond_to?(:set)
+          cache.set(key, value)
+
+        # `Cache#[key]=value` so `Hash` can be used
+        elsif cache.respond_to?(:[]=)
+          cache[key] = value
+
+        # `Cache#write(key, value)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:write)
+          cache.write(key, value)
+        end
+
+        value
+      end
+    end
+
+    def self.get_map_cache(sprockets, logical_path)
+      logical_path = logical_path.gsub(/\.js#{REGEXP_END}/, '')
+      cache_key = cache_key_for_path(logical_path+'.map')
+      cache(sprockets).cache_get(cache_key)
+    end
+
+    def self.set_map_cache(sprockets, logical_path, map_contents)
+      logical_path = logical_path.gsub(/\.js#{REGEXP_END}/, '')
+      cache_key = cache_key_for_path(logical_path+'.map')
+      cache(sprockets).cache_set(cache_key, map_contents)
+    end
+
+    def self.cache(sprockets)
+      @cache ||= sprockets.cache ? sprockets : Cache.new
+    end
+
+    def self.cache_key_for_path(logical_path)
+      base_name = logical_path.gsub(/\.js#{REGEXP_END}/, '')
+      File.join('opal', 'source_maps', base_name)
+    end
+
+
+    def initialize sprockets, prefix = '/'
+      @sprockets = sprockets
+      @prefix = prefix
+    end
+
+    attr_reader :sprockets, :prefix
+
+    def inspect
+      "#<#{self.class}:#{object_id}>"
+    end
+
+    def call(env)
+      prefix_regex = %r{^(?:#{prefix}/|/)}
+      path_info = env['PATH_INFO'].to_s.sub(prefix_regex, '')
+
+      case path_info
+      when %r{^(.*)\.self\.map$}
+        path = $1
+        asset  = sprockets[path+'.js']
+        return not_found(path) if asset.nil?
+
+        # "logical_name" of a BundledAsset keeps the .js extension
+        source = SourceMapServer.get_map_cache(sprockets, asset.logical_path)
+        return not_found(asset) if source.nil?
+
+        map = JSON.parse(source)
+        map['sources'] = map['sources'].map {|s| "#{prefix}/#{s}"}
+        source = map.to_json
+
+        return [200, {"Content-Type" => "text/json"}, [source.to_s]]
+      when %r{^(.*)\.rb$}
+        begin
+          asset = sprockets.resolve(path_info.sub(/\.rb#{REGEXP_END}/,''))
+        rescue Sprockets::FileNotFound
+          return not_found(path_info)
+        end
+        return [200, {"Content-Type" => "text/ruby"}, [Pathname(asset).read]]
+      else
+        not_found(path_info)
+      end
+    end
+
+    def not_found(*messages)
+      not_found = [404, {}, [{not_found: messages}.inspect]]
+    end
+  end
+end

data/lib/opal/sprockets/version.rb

@@ -1,8 +1,8 @@
 module Opal
   module Sprockets
     BASE_VERSION = '0.4.0'
-    OPAL_VERSION = '0.10.0'
-    SPROCKETS_VERSION = '3.0'
-    VERSION = "#{BASE_VERSION}.#{OPAL_VERSION}.#{SPROCKETS_VERSION}.0"
+    OPAL_VERSION = '0.11.dev'
+    SPROCKETS_VERSION = '3.1'
+    VERSION = "#{BASE_VERSION}.#{OPAL_VERSION}.#{SPROCKETS_VERSION}.beta1"
   end
 end

data/lib/opal/sprockets.rb

@@ -0,0 +1,92 @@
+require 'opal'
+require 'opal/sprockets/processor'
+require 'opal/sprockets/erb'
+require 'opal/sprockets/server'
+
+module Opal
+  module Sprockets
+    # Bootstraps modules loaded by sprockets on `Opal.modules` marking any
+    # non-Opal asset as already loaded.
+    #
+    # @example
+    #
+    #   Opal::Sprockets.load_asset(Rails.application.assets, 'application')
+    #
+    # @example Will output the following JavaScript:
+    #
+    #   if (typeof(Opal) !== 'undefined') {
+    #     Opal.loaded("opal");
+    #     Opal.loaded("jquery.self");
+    #     Opal.load("application");
+    #   }
+    #
+    # @param name      [String] The logical name of the main asset to be loaded (without extension)
+    # @param sprockets [Sprockets::Environment]
+    #
+    # @return [String] JavaScript code
+    def self.load_asset(name, sprockets)
+      asset = sprockets[name.sub(/(\.(js|rb|opal))*#{REGEXP_END}/, '.js')]
+      return '' if asset.nil?
+
+      opal_extnames = sprockets.engines.map do |ext, engine|
+        ext if engine <= ::Opal::Processor
+      end.compact
+
+      module_name       = -> asset { asset.logical_path.sub(/\.js#{REGEXP_END}/, '') }
+      path_extnames     = -> path  { File.basename(path).scan(/\.[^.]+/) }
+      mark_loaded       = -> paths { "Opal.loaded([#{paths.map(&:inspect).join(',')}]);" }
+      processed_by_opal = -> asset { (path_extnames[asset.pathname] & opal_extnames).any? }
+      stubbed_files     = ::Opal::Config.stubbed_files
+
+      non_opal_assets = ([asset]+asset.dependencies)
+        .select { |asset| not(processed_by_opal[asset]) }
+        .map { |asset| module_name[asset] }
+
+      loaded = ['opal'] + non_opal_assets + stubbed_files.to_a
+
+      if processed_by_opal[asset]
+        load_asset_code = "Opal.load(#{module_name[asset].inspect});"
+      end
+
+
+      "if (typeof(Opal) !== 'undefined') { "\
+        "#{mark_loaded[loaded]} "\
+        "#{load_asset_code} "\
+      "}"
+    end
+
+    # Generate a `<script>` tag for Opal assets.
+    #
+    # @param [String] name     The logical name of the asset to be loaded (without extension)
+    # @param [Hash]   options  The options about sprockets
+    # @option options [Sprockets::Environment] :sprockets  The sprockets instance
+    # @option options [String]                 :prefix     The prefix String at which is mounted Sprockets, e.g. '/assets'
+    # @option options [Boolean]                :debug      Wether to enable debug mode along with sourcemaps support
+    #
+    # @return a string of HTML code containing `<script>` tags.
+    def self.javascript_include_tag(name, options = {})
+      sprockets = options.fetch(:sprockets)
+      prefix    = options.fetch(:prefix)
+      debug     = options.fetch(:debug)
+
+      # Avoid double slashes
+      prefix = prefix.chop if prefix.end_with? '/'
+
+      asset = sprockets[name]
+      raise "Cannot find asset: #{name}" if asset.nil?
+      scripts = []
+
+      if debug
+        asset.to_a.map do |dependency|
+          scripts << %{<script src="#{prefix}/#{dependency.logical_path}?body=1"></script>}
+        end
+      else
+        scripts << %{<script src="#{prefix}/#{name}.js"></script>}
+      end
+
+      scripts << %{<script>#{::Opal::Sprockets.load_asset(name, sprockets)}</script>}
+
+      scripts.join "\n"
+    end
+  end
+end

data/lib/opal-sprockets.rb

@@ -1,5 +1 @@
-require 'opal'
 require 'opal/sprockets'
-require 'opal/sprockets/version'
-
-Opal::Sprockets::Server = ::Opal::Server

data/opal-sprockets.gemspec

@@ -4,11 +4,11 @@ require File.expand_path('../lib/opal/sprockets/version', __FILE__)
 Gem::Specification.new do |s|
   s.name         = 'opal-sprockets'
   s.version      = Opal::Sprockets::VERSION
-  s.authors      = ['Elia Schito', 'Adam Beynon']
-  s.email        = 'elia@schito.me'
+  s.author       = 'Adam Beynon'
+  s.email        = 'adam.beynon@gmail.com'
   s.homepage     = 'http://opalrb.org'
-  s.summary      = 'Sprockets support for Opal.'
-  s.description  = 'Sprockets support for Opal.'
+  s.summary      = 'Sprockets support for opal'
+  s.description  = 'Sprockets suppoer for opal.'
 
   s.files          = `git ls-files`.split("\n")
   s.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-sprockets
 version: !ruby/object:Gem::Version
-  version: 0.4.0.0.10.0.3.0.0
+  version: 0.4.0.0.11.dev.3.1.beta1
 platform: ruby
 authors:
-- Elia Schito
 - Adam Beynon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-18 00:00:00.000000000 Z
+date: 2016-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sprockets
@@ -17,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: opal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.dev
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.dev
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -95,8 +94,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Sprockets support for Opal.
-email: elia@schito.me
+description: Sprockets suppoer for opal.
+email: adam.beynon@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -113,6 +112,14 @@ files:
 - example/config.ru
 - example/index.html
 - lib/opal-sprockets.rb
+- lib/opal/sprockets.rb
+- lib/opal/sprockets/environment.rb
+- lib/opal/sprockets/erb.rb
+- lib/opal/sprockets/path_reader.rb
+- lib/opal/sprockets/processor.rb
+- lib/opal/sprockets/server.rb
+- lib/opal/sprockets/source_map_header_patch.rb
+- lib/opal/sprockets/source_map_server.rb
 - lib/opal/sprockets/version.rb
 - opal-sprockets.gemspec
 - spec/fixtures/complex_sprockets.js.rb.erb
@@ -152,15 +159,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
-summary: Sprockets support for Opal.
+summary: Sprockets support for opal
 test_files:
 - spec/fixtures/complex_sprockets.js.rb.erb
 - spec/fixtures/file_with_directives.js