opal-sprockets 0.4.7.1.0.3.7 → 1.0.1

data/lib/opal/sprockets/server.rb

@@ -2,115 +2,111 @@ require 'erb'
 require 'rack'
 require 'sprockets'
 
-module Opal
-  module Sprockets
-    class Server
-      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
+class Opal::Sprockets::Server
+  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 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 = enabled
+  end
 
-      def source_map_enabled
-        Opal::Config.source_map_enabled
-      end
+  def source_map_enabled
+    Opal::Config.source_map_enabled
+  end
 
-      def append_path path
-        @sprockets.append_path path
-      end
+  def append_path path
+    @sprockets.append_path path
+  end
 
-      def use_gem gem_name
-        @sprockets.use_gem gem_name
-      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
-
-        @app = Rack::Builder.app do
-          not_found = lambda { |env| [404, {}, []] }
-          use Rack::Deflater
-          use Rack::ShowExceptions
-          use Index, server if server.use_index
-          map(prefix)      { run sprockets }
-          run Rack::Static.new(not_found, root: server.public_root, urls: server.public_urls)
-        end
-      end
+  def create_app
+    server, sprockets, prefix = self, @sprockets, self.prefix
+    sprockets.logger.level ||= Logger::DEBUG
+
+    @app = Rack::Builder.app do
+      not_found = lambda { |env| [404, {}, []] }
+      use Rack::Deflater
+      use Rack::ShowExceptions
+      use Index, server if server.use_index
+      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)
+    def call(env)
+      if %w[/ /index.html].include? env['PATH_INFO']
+        [200, { 'Content-Type' => 'text/html' }, [html]]
+      else
         @app.call env
       end
+    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
+    # 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

data/lib/opal/sprockets/version.rb

@@ -1,12 +1,5 @@
 module Opal
   module Sprockets
-    BASE_VERSION = '0.4.7'
-    OPAL_VERSION = '1.0.0'
-    SPROCKETS_VERSION = '3.7'
-
-    # Just keep the first two segments of dependencies' versions
-    v = -> v { v.split('.')[0..1].compact.join('.') }
-
-    VERSION = "#{BASE_VERSION}.#{v[OPAL_VERSION]}.#{v[SPROCKETS_VERSION]}"
+    VERSION = '1.0.1'
   end
 end

data/opal-sprockets.gemspec

@@ -1,25 +1,39 @@
-# -*- encoding: utf-8 -*-
-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.homepage     = 'https://github.com/opal/opal-sprockets#readme'
-  s.summary      = 'Sprockets support for Opal.'
-  s.description  = 'Sprockets support for Opal.'
-
-  s.files          = `git ls-files`.split("\n")
-  s.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths  = ['lib']
-
-  s.add_dependency 'sprockets', "~> #{Opal::Sprockets::SPROCKETS_VERSION}"
-  s.add_dependency 'opal', "~> #{Opal::Sprockets::OPAL_VERSION}"
-  s.add_dependency 'tilt', '>= 1.4'
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rack-test'
-  s.add_development_dependency 'sourcemap'
+require_relative 'lib/opal/sprockets/version'
+
+Gem::Specification.new do |spec|
+  spec.name         = 'opal-sprockets'
+  spec.version      = Opal::Sprockets::VERSION
+  spec.authors      = ['Elia Schito', 'Adam Beynon']
+  spec.email        = 'elia@schito.me'
+
+  spec.summary      = 'Sprockets support for Opal.'
+  spec.homepage     = 'https://github.com/opal/opal-sprockets#readme'
+  spec.license      = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/opal/opal-sprockets'
+  spec.metadata['changelog_uri'] = 'https://github.com/opal/opal-sprockets/blob/master/CHANGELOG.md'
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5', '< 3.1')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'sprockets', "~> 4.0"
+  spec.add_dependency 'opal', [">= 1.0", "< 2.0"]
+  spec.add_dependency 'tilt', '>= 1.4'
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'sourcemap'
+  spec.add_development_dependency 'ejs'
+  spec.add_development_dependency 'pry'
 end

data/spec/fixtures/complex_sprockets.js.rb.erb

@@ -1,5 +1,5 @@
 #= require no_requires
-//= require jst_file
+#= require ./jst_file
 #= require_tree ./required_tree_test
 require 'file_with_directives'
 require <%= "base64".inspect %>

data/spec/spec_helper.rb

@@ -1,2 +1,9 @@
 require 'bundler'
 Bundler.require
+
+RSpec.configure do |config|
+  config.before do
+    Opal::Config.reset!
+    Opal::Sprockets::Processor.reset_cache_key!
+  end
+end

data/spec/sprockets/erb_spec.rb

@@ -1,38 +1,28 @@
 require 'spec_helper'
 require 'opal/sprockets/erb'
 
-describe Opal::ERB::Processor do
+describe Opal::Sprockets::ERB do
   let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
-  let(:environment) { double(Sprockets::Environment,
-    cache: nil,
-    :[] => nil,
-    resolve: pathname.expand_path.to_s,
-    engines: double(keys: %w[.rb .js .erb .opal]),
-  ) }
-  let(:sprockets_context) { double(Sprockets::Context,
-    logical_path: "foo.#{ext}",
-    environment: environment,
-    pathname: pathname,
+  let(:data) { %{<% print("") %><a href="<%= url %>"><%= name %></a>} }
+  let(:input) { {
+    environment: Opal::Sprockets::Environment.new.tap {|e| e.append_path "/Code/app/mylib/opal"},
+    data: data,
     filename: pathname.to_s,
-    root_path: '/Code/app/mylib',
-    is_a?: true,
-  ) }
-  let(:required_assets) { [] }
-  let(:template) { described_class.new { |t| %Q{<% print("") %><a href="<%= url %>"><%= name %></a>} } }
-  before { allow(sprockets_context).to receive(:require_asset) {|asset| required_assets << asset } }
-
+    load_path: "/Code/app/mylib/opal",
+    metadata: {},
+    cache: Sprockets::Cache.new
+  } }
   let(:ext) { 'opalerb' }
 
-  it "is registered for '.opalerb' files" do
-    expect(Tilt["test.#{ext}"]).to eq(described_class)
-  end
-
   it 'renders the template' do
-    expect(template.render(sprockets_context)).to include('"<a href=\""')
+    result = described_class.call(input)
+
+    expect(result[:data]).to include('"<a href=\""')
   end
 
   it 'implicitly requires "erb"' do
-    template.render(sprockets_context)
-    expect(required_assets).to eq(['erb'])
+    result = described_class.call(input)
+
+    expect(result[:required].first).to include("stdlib/erb.rb")
   end
 end

data/spec/sprockets/processor_spec.rb

@@ -1,79 +1,75 @@
 require 'spec_helper'
 require 'opal/sprockets/processor'
 
-describe Opal::Processor do
+describe Opal::Sprockets::Processor do
   let(:pathname) { Pathname("/Code/app/mylib/opal/foo.#{ext}") }
-  let(:environment) { double(Sprockets::Environment,
-    cache: nil,
-    :[] => nil,
-    resolve: pathname.expand_path.to_s,
-    engines: double(keys: %w[.rb .js .opal]),
-  ) }
-  let(:sprockets_context) { double(Sprockets::Context,
-    logical_path: "foo.#{ext}",
-    environment: environment,
-    pathname: pathname,
+  let(:data) { "foo" }
+  let(:input) { {
+    environment: Opal::Sprockets::Environment.new.tap {|e| e.append_path "/Code/app/mylib/opal"},
+    data: data,
     filename: pathname.to_s,
-    root_path: '/Code/app/mylib',
-    is_a?: true,
-  ) }
+    load_path: "/Code/app/mylib/opal",
+    metadata: {},
+    cache: Sprockets::Cache.new
+  } }
+
+  before do
+    allow(Sprockets::SourceMapUtils).to receive(:format_source_map)
+    allow(Sprockets::SourceMapUtils).to receive(:combine_source_maps)
+  end
 
   %w[.rb .opal].each do |ext|
-    let(:ext) { ext }
+    describe %{with extension "#{ext}"} do
+      let(:ext) { ext }
 
-    describe %Q{with extension "#{ext}"} do
       it "is registered for '#{ext}' files" do
-        expect(Sprockets.engines[ext]).to eq(described_class)
+        mime_type = Sprockets.mime_types.find { |_,v| v[:extensions].include? ".rb" }.first
+        transformers = Sprockets.transformers[mime_type]
+        transformer = transformers["application/javascript"]
+        expect(transformer.processors).to include(described_class)
       end
 
-      it "compiles and evaluates the template on #render" do
-        template = described_class.new { |t| "puts 'Hello, World!'\n" }
-        expect(template.render(sprockets_context)).to include('"Hello, World!"')
+      it "compiles the code" do
+        result = described_class.call(input.merge data: "puts 'Hello, World!'\n")
+
+        expect(result[:data]).to include('"Hello, World!"')
       end
-    end
-  end
 
-  describe '.stubbed_files' do
-    around do |e|
-      config.stubbed_files.clear
-      e.run
-      config.stubbed_files.clear
-    end
+      describe '.stubbed_files' do
+        it 'requires non-stubbed files' do
+          result = described_class.call(input.merge(data: 'require "set"'))
 
-    let(:stubbed_file) { 'foo' }
-    let(:template) { described_class.new { |t| "require #{stubbed_file.inspect}" } }
-    let(:config) { Opal::Config }
+          expect(result[:required].first).to include("stdlib/set.rb")
+        end
 
-    it 'usually require files' do
-      expect(sprockets_context).to receive(:require_asset).with(stubbed_file)
-      template.render(sprockets_context)
-    end
+        it 'skips require of stubbed file' do
+          Opal::Config.stubbed_files << 'set'
+          result = described_class.call(input.merge(data: "require 'set'"))
 
-    it 'skips require of stubbed file' do
-      config.stubbed_files << stubbed_file.to_s
-      expect(sprockets_context).not_to receive(:require_asset).with(stubbed_file)
-      template.render(sprockets_context)
-    end
+          expect(result[:required]).not_to include("set.rb")
+        end
 
-    it 'marks a stubbed file as loaded' do
-      config.stubbed_files << stubbed_file.to_s
-      asset = double(dependencies: [], pathname: Pathname('bar'), logical_path: 'bar')
-      allow(environment).to receive(:[]).with('bar.js') { asset }
-      allow(environment).to receive(:engines) { {'.rb' => described_class, '.opal' => described_class} }
+        it 'marks a stubbed file as loaded' do
+          Opal::Config.stubbed_files << 'set'
+          result = described_class.call(input.merge(data: "require 'set'"))
 
-      code = ::Opal::Sprockets.load_asset('bar')
-      expect(code).to match(stubbed_file)
-    end
-  end
+          expect(result[:data]).not_to include(::Opal::Sprockets.load_asset('set'))
+        end
+      end
 
-  describe '.cache_key' do
-    it 'can be reset' do
-      Opal::Config.arity_check_enabled = true
-      old_cache_key = described_class.cache_key
-      Opal::Config.arity_check_enabled = false
-      expect(described_class.cache_key).to eq(old_cache_key)
-      described_class.reset_cache_key!
-      expect(described_class.cache_key).not_to eq(old_cache_key)
+      describe '.cache_key' do
+        it 'can be reset' do
+          old_cache_key = described_class.cache_key
+          Opal::Config.arity_check_enabled = !Opal::Config.arity_check_enabled
+          stale_cache_key = described_class.cache_key
+
+          described_class.reset_cache_key!
+          reset_cache_key = described_class.cache_key
+
+          expect(stale_cache_key).to eq(old_cache_key)
+          expect(reset_cache_key).not_to eq(old_cache_key)
+        end
+      end
     end
   end
 end