opal-sprockets 0.4.5.1.0.3.7 → 1.0.0

data/lib/opal/sprockets/version.rb

@@ -1,12 +1,5 @@
 module Opal
   module Sprockets
-    BASE_VERSION = '0.4.5'
-    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.0'
   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", "< 1.2"]
+  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

data/spec/sprockets/server_spec.rb

@@ -20,60 +20,130 @@ describe Opal::Sprockets::Server do
   end
 
   it 'serves assets with complex sprockets requires' do
-    asset = app.sprockets['complex_sprockets']
+    asset = app.sprockets['complex_sprockets', accept: "application/javascript"]
     expect(asset).to be_truthy
 
-    assets = asset.to_a.map do |sub_asset|
-      sub_asset.logical_path.gsub(/\.self\.js$/, '.js')
+    assets = asset.metadata[:included].map do |sub_asset|
+      URI.parse(sub_asset).path.split(%r'/fixtures/|/stdlib/').last
     end
 
     %w[
-      base64.js
-      no_requires.js
-      jst_file.js
-      required_tree_test/required_file1.js
-      required_tree_test/required_file2.js
+      base64.rb
+      no_requires.rb
+      jst_file.jst.ejs
+      required_tree_test/required_file1.rb
+      required_tree_test/required_file2.rb
       file_with_directives.js
     ].each do |logical_path|
       expect(assets).to include(logical_path)
     end
   end
 
+  it 'recompiles the asset when its dependencies change' do
+    does_include = proc do |it, what, what_not=[], what_else=nil, what_else_not=nil|
+      expect(it).to include what_else if what_else
+      expect(it).not_to include what_else_not if what_else_not
+      what.each { |i| expect(it).to include %{modules["required_tree_test/required_file#{i}"]} }
+      what_not.each { |i| expect(it).not_to include %{modules["required_tree_test/required_file#{i}"]} }
+    end
+
+    ["default", "debug"].each do |pipeline|
+      asset = app.sprockets['require_tree_test', pipeline: pipeline, accept: "application/javascript"]
+      expect(asset).to be_truthy
+      does_include.(asset.to_s, [1,2], [3], nil, "UNIQUESTRING")
+      get "/assets/require_tree_test.#{pipeline}.js"
+      does_include.(last_response.body, [1,2], [3], nil, "UNIQUESTRING")
+
+      sleep 1 # Make sure to modify mtime
+
+      File.write(__dir__+"/../fixtures/required_tree_test/required_file2.rb", "p 'UNIQUESTRING1'")
+
+      asset = app.sprockets['require_tree_test', pipeline: pipeline, accept: "application/javascript"]
+      expect(asset).to be_truthy
+      does_include.(asset.to_s, [1,2], [3], "UNIQUESTRING1")
+      get "/assets/require_tree_test.#{pipeline}.js"
+      does_include.(last_response.body, [1,2], [3], "UNIQUESTRING1")
+
+      sleep 1 # Make sure to modify mtime
+
+      File.write(__dir__+"/../fixtures/required_tree_test/required_file2.rb", "p 'UNIQUESTRING2'")
+
+      asset = app.sprockets['require_tree_test', pipeline: pipeline, accept: "application/javascript"]
+      expect(asset).to be_truthy
+      does_include.(asset.to_s, [1,2], [3], "UNIQUESTRING2")
+      get "/assets/require_tree_test.#{pipeline}.js"
+      does_include.(last_response.body, [1,2], [3], "UNIQUESTRING2")
+
+      sleep 1 # Make sure to modify mtime
+
+      File.write(__dir__+"/../fixtures/required_tree_test/required_file2.rb", "p 'UNIQUESTRING3'")
+      File.write(__dir__+"/../fixtures/required_tree_test/required_file3.rb", "p 3")
+
+      asset = app.sprockets['require_tree_test', pipeline: pipeline, accept: "application/javascript"]
+      expect(asset).to be_truthy
+      does_include.(asset.to_s, [1,2,3], [], "UNIQUESTRING3")
+      get "/assets/require_tree_test.#{pipeline}.js"
+      does_include.(last_response.body, [1,2], [], "UNIQUESTRING3") # fails with 3 - it doesn't get new files
+
+      sleep 1 # Make sure to modify mtime
+    ensure
+      File.write(__dir__+"/../fixtures/required_tree_test/required_file2.rb", "p 2\n")
+      File.unlink(__dir__+"/../fixtures/required_tree_test/required_file3.rb") rescue nil
+    end
+  end
+
   describe 'source maps' do
-    RSpec::Matchers.define :include_inline_source_map do
+    RSpec::Matchers.define :include_source_map do
       match do |actual_response|
         actual_response.ok? &&
-        actual_response.body.lines.last.start_with?('//# sourceMappingURL=data:application/json;base64,')
+        actual_response.body.lines.last.start_with?('//# sourceMappingURL=')
       end
     end
 
-    def extract_inline_map(response)
+    def extract_map(path, response)
       last_line   = response.body.lines.last
-      b64_encoded = last_line.split('//# sourceMappingURL=data:application/json;base64,', 2)[1]
-      json_string = Base64.decode64(b64_encoded)
+      if last_line.start_with? "//# sourceMappingURL=data:application/json;base64,"
+        b64_encoded = last_line.split('//# sourceMappingURL=data:application/json;base64,', 2)[1]
+        json_string = Base64.decode64(b64_encoded)
+      else
+        map_file = last_line.split('//# sourceMappingURL=', 2)[1].chomp
+        map_file = relative_path(path, map_file)
+        map_file = get map_file
+        json_string = map_file.body
+      end
       JSON.parse(json_string, symbolize_names: true)
     end
 
+    def relative_path(path, file)
+      URI.join("http://example.com/", path, file).path
+    end
+
     it 'serves map for a top level file' do
-      get '/assets/opal_file.js'
-      expect(last_response).to include_inline_source_map
+      path = '/assets/opal_file.debug.js'
+      get path
+      expect(last_response).to include_source_map
 
-      map = extract_inline_map(last_response)
+      map = extract_map(path, last_response)
 
-      expect(map[:sources]).to eq(['opal_file.rb']).or eq(['opal_file'])
-      expect(map[:sourcesContent]).to eq(["require 'opal'\nputs 'hi from opal!'\n"])
+      expect(map[:file]).to eq('opal_file.rb')
+      expect(map[:sections].last[:map][:sources]).to eq(['opal_file.source.rb'])
+
+      expect(get(relative_path(path, map[:sections].last[:map][:sources][0])).body.chomp)
+        .to eq("require 'opal'\nputs 'hi from opal!'")
     end
 
     it 'serves map for a subfolder file' do
-      get '/assets/source_map/subfolder/other_file.self.js'
-      expect(last_response).to include_inline_source_map
+      path = '/assets/source_map/subfolder/other_file.debug.js'
+      get path
+      expect(last_response).to include_source_map
+
+      map = extract_map(path, last_response)
 
-      map = extract_inline_map(last_response)
+      expect(map[:file]).to eq('source_map/subfolder/other_file.rb')
+      expect(map[:sections].first[:map][:sources]).to eq(['other_file.source.rb'])
 
-      expect(map[:sources])
-        .to eq(['source_map/subfolder/other_file.rb'])
-        .or eq(['source_map/subfolder/other_file'])
-      expect(map[:sourcesContent]).to eq(["puts 'other!'\n"])
+      expect(get(relative_path(path, map[:sections][0][:map][:sources][0])).body.chomp)
+        .to eq("puts 'other!'")
     end
   end
 end

data/spec/sprockets_spec.rb

@@ -8,20 +8,20 @@ describe Opal::Sprockets do
   describe '.load_asset' do
     it 'loads the main asset' do
       code = described_class.load_asset('console')
-      expect(code).to include('Opal.load("console");')
+      expect(code).to include('Opal.require("console");')
     end
 
     it 'marks as loaded stubs and all non-opal assets' do
       allow(Opal::Config).to receive(:stubbed_files) { %w[foo bar] }
 
       code = described_class.load_asset('baz')
-      expect(code).to include('Opal.loaded(["foo","bar"].concat(OpalLoaded || []));')
-      expect(code).to include('Opal.load("baz");')
+      expect(code).to include(%{Opal.loaded(["foo","bar"].concat(typeof(OpalLoaded) === "undefined" ? [] : OpalLoaded));})
+      expect(code).to include('Opal.require("baz");')
     end
 
     it 'tries to load an asset if it is registered as opal module' do
       code = described_class.load_asset('foo')
-      expect(code).to include('Opal.load("foo");')
+      expect(code).to include('Opal.require("foo");')
     end
 
     it 'warns the user that passing an env is not needed, only once' do
@@ -35,16 +35,16 @@ describe Opal::Sprockets do
 
     it 'accepts multiple names' do
       code = described_class.load_asset('foo', 'bar')
-      expect(code).to include('Opal.load("foo");')
-      expect(code).to include('Opal.load("bar");')
+      expect(code).to include('Opal.require("foo");')
+      expect(code).to include('Opal.require("bar");')
     end
 
     it 'detects deprecated env with multiple names' do
       code = described_class.load_asset('foo', 'bar', env)
       expect(code).to eq([
-        'Opal.loaded(OpalLoaded || []);',
-        'Opal.load("foo");',
-        'Opal.load("bar");',
+        'Opal.loaded(typeof(OpalLoaded) === "undefined" ? [] : OpalLoaded);',
+        'Opal.require("foo");',
+        'Opal.require("bar");',
       ].join("\n"))
     end
   end