opal 0.10.3 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9537a1e10b3a6f999f8d9abae55d49398f938aa6
-  data.tar.gz: e39781ef2ad2832e32142bfe27dc69e61aa9c64d
+  metadata.gz: 89554baf418fe68fca2684442d11d361b74c6771
+  data.tar.gz: 7e44601e429aae698df5656a952447be076fc90f
 SHA512:
-  metadata.gz: 985d042cb190d1f0fb610fbf96dd7ac099fd1e6b606e60f0c7445bf324621d57d6e272076885559b378edd54f5b4fe937fa2b82d4e8e7ece01998946637226af
-  data.tar.gz: 2c4fdb0cf980e8c8c24305f0ec4020bf32fdde88b43732a88dffee61cfb4be55f3357bc2c23f0a58df2494825234b80d7140981bd93751008d27d701335594b0
+  metadata.gz: 6fc37070ccc46ba143fdad2056837f5dea4fc1bc3f3afbbd2839e978e85e005653301bafbba303af5e7f56b26158a64b9903b3385f8fda872a62cc09ecde0f57
+  data.tar.gz: 816cc90b77dbaa07d4bac8bcc32a54e218d6b1b9411a6c864b8f3eb87474c57bff6d648b18a295978c28e6387eae68bb4440d4b2d24f18b8e53ea48c450130cc

data/.rspec

@@ -1,3 +1,2 @@
 --color
---format progress
---pattern spec/lib/**/*_spec.rb
+--require lib/spec_helper

data/.travis.yml

@@ -11,31 +11,31 @@ matrix:
   fast_finish: true
 
   include:
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=jshint SUITE=core
 
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=jshint SUITE=stdlib
 
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=mspec_opal_nodejs
 
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=mspec_ruby_nodejs TZ="/usr/share/zoneinfo/Pacific/Fiji"
 
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=mspec_ruby_sprockets_phantomjs
 
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=minitest
 
-    - rvm: 2.3.1
+    - rvm: 2.3.3
       env: RUN=rspec RACK_VERSION='~> 2.0.0' CHECK_COVERAGE=true
 
     - rvm: ruby-head
       env: RUN=rspec
 
-    - rvm: 2.2.4
+    - rvm: 2.2.6
       env: RUN=rspec TILT_VERSION=2.0.1 SPROCKETS_VERSION='~> 3.7'
 
     - rvm: 2.1.10
@@ -44,10 +44,7 @@ matrix:
     - rvm: 2.0.0
       env: RUN="rspec mspec_opal_nodejs" RACK_VERSION='< 2.0'
 
-    - rvm: rbx
-      env: RUN=rspec
-
-    - rvm: jruby-9.0.5.0
+    - rvm: jruby-9.1.6.0
       env: RUN=rspec
 
     - rvm: jruby-head
@@ -55,7 +52,6 @@ matrix:
 
   allow_failures:
     - rvm: ruby-head
-    - rvm: rbx
     - rvm: jruby-head
 
 
@@ -66,6 +62,7 @@ before_install:
   - git submodule update --init
   - npm install -g jshint
   - npm install -g uglify-js
+  - bundle config without doc
 
 script:
   - "bundle exec rake $RUN"

data/.yardopts

@@ -1,6 +1,8 @@
 lib/opal.rb
 lib/opal/**/*.rb
---markup markdown
+--markup=markdown
+--markup-provider=redcarpet
+--hide-void-return
 -
 CHANGELOG.md
 docs/compiler_directives.md

data/Gemfile

@@ -35,3 +35,5 @@ unless ENV['CI']
 end
 
 gem 'mspec', path: 'spec/mspec'
+
+gem 'redcarpet', group: :doc

data/lib/opal/config.rb

@@ -2,53 +2,130 @@ require 'set'
 
 module Opal
   module Config
-    def self.default_config
-      {
-        method_missing_enabled:    true,
-        arity_check_enabled:       false,
-        freezing_stubs_enabled:    true,
-        tainting_stubs_enabled:    true,
-        const_missing_enabled:     true,
-        dynamic_require_severity:  :warning, # :error, :warning or :ignore
-        irb_enabled:               false,
-        inline_operators_enabled:  true,
-        source_map_enabled:        true,
-        stubbed_files:             Set.new,
-      }
+    extend self
+
+    private
+
+    def config_options
+      @config_options ||= {}
     end
 
-    def self.config
-      @config ||= default_config
+    # Defines a new configuration option
+    #
+    # @param [String] name the option name
+    # @param [Object] default_value the option's default value
+    # @!macro [attach] property
+    #   @!attribute [rw] $1
+    def config_option(name, default_value, options = {})
+      compiler      = options.fetch(:compiler_option, nil)
+      valid_values  = options.fetch(:valid_values , [true, false])
+
+      config_options[name] = {
+        default: default_value,
+        compiler: compiler,
+      }
+
+      define_singleton_method(name) { config.fetch(name, default_value) }
+      define_singleton_method("#{name}=") do |value|
+        unless valid_values.any? { |valid_value| valid_value === value }
+          raise ArgumentError, "Not a valid value for option #{self}.#{name}, provided #{value.inspect}. "\
+                               "Must be #{valid_values.inspect} === #{value.inspect}"
+        end
+
+        config[name] = value
+      end
     end
 
-    def self.reset!
-      @config = nil
+    public
+
+    # @return [Hash] the default configuration
+    def default_config
+      default_config = {}
+      config_options.each do |name, options|
+        default_value = options.fetch(:default)
+        default_value = Proc === default_value ? default_value.call : default_value
+        default_config[name] = default_value
+      end
+      default_config
     end
 
-    COMPILER_KEYS = {
-      # Compiler option name:   # Config option name
-      method_missing:           :method_missing_enabled,
-      arity_check:              :arity_check_enabled,
-      freezing:                 :freezing_stubs_enabled,
-      tainting:                 :tainting_stubs_enabled,
-      const_missing:            :const_missing_enabled,
-      dynamic_require_severity: :dynamic_require_severity,
-      irb:                      :irb_enabled,
-      inline_operators:         :inline_operators_enabled,
-    }
-
-    def self.compiler_options
-      config = self.config
+    # @return [Hash] the configuration for Opal::Compiler
+    def compiler_options
       compiler_options = {}
-      COMPILER_KEYS.each do |compiler_option_name, option_name|
-        compiler_options[compiler_option_name] = config[option_name]
+      config_options.each do |name, options|
+        compiler_option_name = options.fetch(:compiler)
+        compiler_options[compiler_option_name] = config.fetch(name)
       end
       compiler_options
     end
 
-    default_config.keys.each do |config_option|
-      define_singleton_method(config_option) { config[config_option] }
-      define_singleton_method("#{config_option}=") { |value| config[config_option] = value }
+    # @return [Hash] the current configuration, defaults to #default_config
+    def config
+      @config ||= default_config
     end
+
+    # Resets the config to its default value
+    #
+    # @return [void]
+    def reset!
+      @config = nil
+    end
+
+
+    # Enable method_missing support.
+    #
+    # @return [true, false]
+    config_option :method_missing_enabled, true, compiler_option: :method_missing
+
+    # Enable const_missing support.
+    #
+    # @return [true, false]
+    config_option :const_missing_enabled, true, compiler_option: :const_missing
+
+    # Enable arity check on the arguments passed to methods, procs and lambdas.
+    #
+    # @return [true, false]
+    config_option :arity_check_enabled, false, compiler_option: :arity_check
+
+    # Add stubs for methods related to freezing objects (for compatibility).
+    #
+    # @return [true, false]
+    config_option :freezing_stubs_enabled, true, compiler_option: :freezing
+
+    # Add stubs for methods related to tainting objects (for compatibility).
+    #
+    # @return [true, false]
+    config_option :tainting_stubs_enabled, true, compiler_option: :tainting
+
+    # Set the error severity for when a require can't be solved at compile time.
+    #
+    # - `:error` will raise an error at compile time
+    # - `:warning` will print a warning on stderr at compile time
+    # - `:ignore` will skip the require silently at compile time
+    #
+    # @return [:error, :warning, :ignore]
+    config_option :dynamic_require_severity, :warning, compiler_option: :dynamic_require_severity, valid_values: [:error, :warning, :ignore]
+
+    # Enable IRB support for making local variables across multiple compilations.
+    #
+    # @return [true, false]
+    config_option :irb_enabled, false, compiler_option: :irb
+
+    # Enable for inline operators optimizations.
+    #
+    # @return [true, false]
+    config_option :inline_operators_enabled, true, compiler_option: :inline_operators
+
+    # Enable source maps support.
+    #
+    # @return [true, false]
+    config_option :source_map_enabled, true
+
+    # A set of stubbed files that will be marked as loaded and skipped during
+    # compilation. The value is expected to be mutated but it's ok to replace
+    # it.
+    #
+    # @return [Set]
+    config_option :stubbed_files, -> { Set.new }, valid_values: [Set]
   end
 end

data/lib/opal/sprockets.rb

@@ -9,7 +9,7 @@ module Opal
     #
     # @example
     #
-    #   Opal::Sprockets.load_asset(Rails.application.assets, 'application')
+    #   Opal::Sprockets.load_asset('application')
     #
     # @example Will output the following JavaScript:
     #
@@ -19,38 +19,24 @@ module Opal
     #     Opal.load("application");
     #   }
     #
-    # @param name      [String] The logical name of the main asset to be loaded (without extension)
-    # @param sprockets [Sprockets::Environment]
+    # @param name [String] The logical name of the main asset to be loaded (without extension)
     #
     # @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
+    def self.load_asset(name, _sprockets = :deprecated)
+      if _sprockets != :deprecated && !@load_asset_warning_displayed
+        @load_asset_warning_displayed = true
+        warn "Passing a sprockets environment to Opal::Sprockets.load_asset no more needed.\n  #{caller(1, 3).join("\n  ")}"
+      end
 
-      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? }
+      name = name.sub(/(\.(js|rb|opal))*\z/, '')
       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
-
+      loaded = ['opal', 'corelib/runtime'] + stubbed_files.to_a
 
       "if (typeof(Opal) !== 'undefined') { "\
-        "#{mark_loaded[loaded]} "\
-        "#{load_asset_code} "\
+        "Opal.loaded(#{loaded.to_json}); "\
+        "if (typeof(OpalLoaded) === 'undefined') Opal.loaded(OpalLoaded); "\
+        "if (Opal.modules[#{name.to_json}]) Opal.load(#{name.to_json}); "\
       "}"
     end
 
@@ -83,7 +69,7 @@ module Opal
         scripts << %{<script src="#{prefix}/#{name}.js"></script>}
       end
 
-      scripts << %{<script>#{::Opal::Sprockets.load_asset(name, sprockets)}</script>}
+      scripts << %{<script>#{::Opal::Sprockets.load_asset(name)}</script>}
 
       scripts.join "\n"
     end

data/lib/opal/sprockets/processor.rb

@@ -48,10 +48,8 @@ module Opal
       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
+      map_contents = compiler.source_map.as_json.to_json
+      ::Opal::SourceMapServer.set_map_cache(sprockets, logical_path, map_contents)
 
       result.to_s
     end
@@ -139,10 +137,37 @@ module Opal
   end
 end
 
+module Opal::Sprockets::Processor
+  module PlainJavaScriptLoader
+    def self.call(input)
+      sprockets = input[:environment]
+      asset = OpenStruct.new(input)
+
+      opal_extnames = sprockets.engines.map do |ext, engine|
+        ext if engine <= ::Opal::Processor
+      end.compact
+
+      path_extnames     = -> path  { File.basename(path).scan(/\.[^.]+/) }
+      processed_by_opal = -> asset { (path_extnames[asset.filename] & opal_extnames).any? }
+
+      unless processed_by_opal[asset]
+        [
+          input[:data],
+          %{if (typeof(OpalLoaded) === 'undefined') OpalLoaded = []; OpalLoaded.push(#{input[:name].to_json});}
+        ].join(";\n")
+      end
+    end
+  end
+end
+
+
 if Sprockets.respond_to? :register_transformer
-  Sprockets.register_engine '.rb',  Opal::Processor, mime_type: 'application/javascript', silence_deprecation: true
-  Sprockets.register_engine '.opal',  Opal::Processor, mime_type: 'application/javascript', silence_deprecation: true
+  extra_args = [{mime_type: 'application/javascript', silence_deprecation: true}]
 else
-  Sprockets.register_engine '.rb',  Opal::Processor
-  Sprockets.register_engine '.opal',  Opal::Processor
+  extra_args = []
 end
+
+Sprockets.register_engine '.rb',  Opal::Processor, *extra_args
+Sprockets.register_engine '.opal',  Opal::Processor, *extra_args
+Sprockets.register_postprocessor 'application/javascript', Opal::Sprockets::Processor::PlainJavaScriptLoader
+

data/lib/opal/version.rb

@@ -1,5 +1,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '0.10.3'
+  VERSION = '0.10.4'
 end

data/opal.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'mspec', '1.5.20'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'racc'
-  s.add_development_dependency 'rspec', '~> 2.99'
+  s.add_development_dependency 'rspec', '~> 3.5.0'
   s.add_development_dependency 'octokit', '~> 2.4.0'
   s.add_development_dependency 'bundler', '~> 1.5'
   s.add_development_dependency 'yard', '~> 0.8.7'

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '2.2.5'
-RUBY_ENGINE_VERSION = '0.10.3'
-RUBY_RELEASE_DATE   = '2016-10-31'
+RUBY_VERSION        = '2.2.6'
+RUBY_ENGINE_VERSION = '0.10.4'
+RUBY_RELEASE_DATE   = '2017-05-06'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = 0
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2015 Adam Beynon'

data/spec/lib/cli_runners/phantomjs_spec.rb

@@ -3,9 +3,9 @@ require 'opal/cli_runners/phantomjs'
 require 'stringio'
 
 describe Opal::CliRunners::Phantomjs do
-  # FIXME: Unfotunately there are some issues on jruby and 1.9.3, probably
+  # FIXME: Unfotunately there are some issues on 1.9.3, probably
   #        related to IO.pipe and process spawning in general.
-  before { pending if RUBY_PLATFORM == 'java' or RUBY_VERSION == '1.9.3' }
+  before { pending if RUBY_VERSION == '1.9.3' }
 
   it 'accepts arguments' do
     expect(output_of(%{

data/spec/lib/config_spec.rb

@@ -2,12 +2,109 @@ require 'lib/spec_helper'
 require 'opal/config'
 
 describe Opal::Config do
+  before { described_class.reset! }
+  after { described_class.reset! }
+
   describe '.default_config' do
     it 'is new each time' do
       default_config1 = described_class.default_config
       default_config2 = described_class.default_config
       expect(default_config1).to eq(default_config2)
       expect(default_config1).not_to equal(default_config2)
+      described_class.default_config[:stubbed_files] << :foo
+      expect(described_class.default_config[:stubbed_files]).to eq(Set.new)
     end
   end
+
+  it 'has expected default values' do
+    expect(described_class.method_missing_enabled).to   eq(true)
+    expect(described_class.const_missing_enabled).to    eq(true)
+    expect(described_class.arity_check_enabled).to      eq(false)
+    expect(described_class.freezing_stubs_enabled).to   eq(true)
+    expect(described_class.tainting_stubs_enabled).to   eq(true)
+    expect(described_class.dynamic_require_severity).to eq(:warning)
+    expect(described_class.irb_enabled).to              eq(false)
+    expect(described_class.inline_operators_enabled).to eq(true)
+    expect(described_class.source_map_enabled).to       eq(true)
+    expect(described_class.stubbed_files).to            eq(Set.new)
+  end
+
+  it 'raises an ArgumentError if provided with an unexpected value' do
+    expect{ described_class.method_missing_enabled   = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.const_missing_enabled    = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.arity_check_enabled      = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.freezing_stubs_enabled   = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.tainting_stubs_enabled   = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.dynamic_require_severity = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.irb_enabled              = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.inline_operators_enabled = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.source_map_enabled       = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.stubbed_files            = :foobar }.to raise_error(ArgumentError)
+  end
+
+  it 'does not raises errors if provided with an expected value' do
+    expect{ described_class.arity_check_enabled      = false }.not_to raise_error
+    expect(described_class.arity_check_enabled).to eq(false)
+
+    expect{ described_class.arity_check_enabled      = true }.not_to raise_error
+    expect(described_class.arity_check_enabled).to eq(true)
+
+    expect{ described_class.const_missing_enabled    = false }.not_to raise_error
+    expect(described_class.const_missing_enabled).to eq(false)
+
+    expect{ described_class.const_missing_enabled    = true }.not_to raise_error
+    expect(described_class.const_missing_enabled).to eq(true)
+
+    expect{ described_class.dynamic_require_severity = :error }.not_to raise_error
+    expect(described_class.dynamic_require_severity).to eq(:error)
+
+    expect{ described_class.dynamic_require_severity = :ignore }.not_to raise_error
+    expect(described_class.dynamic_require_severity).to eq(:ignore)
+
+    expect{ described_class.dynamic_require_severity = :warning }.not_to raise_error
+    expect(described_class.dynamic_require_severity).to eq(:warning)
+
+    expect{ described_class.freezing_stubs_enabled   = false }.not_to raise_error
+    expect(described_class.freezing_stubs_enabled).to eq(false)
+
+    expect{ described_class.freezing_stubs_enabled   = true }.not_to raise_error
+    expect(described_class.freezing_stubs_enabled).to eq(true)
+
+    expect{ described_class.inline_operators_enabled = false }.not_to raise_error
+    expect(described_class.inline_operators_enabled).to eq(false)
+
+    expect{ described_class.inline_operators_enabled = true }.not_to raise_error
+    expect(described_class.inline_operators_enabled).to eq(true)
+
+    expect{ described_class.irb_enabled              = false }.not_to raise_error
+    expect(described_class.irb_enabled).to eq(false)
+
+    expect{ described_class.irb_enabled              = true }.not_to raise_error
+    expect(described_class.irb_enabled).to eq(true)
+
+    expect{ described_class.method_missing_enabled   = false }.not_to raise_error
+    expect(described_class.method_missing_enabled).to eq(false)
+
+    expect{ described_class.method_missing_enabled   = true }.not_to raise_error
+    expect(described_class.method_missing_enabled).to eq(true)
+
+    expect{ described_class.source_map_enabled       = false }.not_to raise_error
+    expect(described_class.source_map_enabled).to eq(false)
+
+    expect{ described_class.source_map_enabled       = true }.not_to raise_error
+    expect(described_class.source_map_enabled).to eq(true)
+
+    expect{ described_class.stubbed_files            << 'foo' }.not_to raise_error
+    expect(described_class.stubbed_files).to eq(['foo'].to_set)
+
+    expect{ described_class.stubbed_files            = %w[foo bar].to_set }.not_to raise_error
+    expect(described_class.stubbed_files).to eq(%w[foo bar].to_set)
+
+    expect{ described_class.tainting_stubs_enabled   = false }.not_to raise_error
+    expect(described_class.tainting_stubs_enabled).to eq(false)
+
+    expect{ described_class.tainting_stubs_enabled   = true }.not_to raise_error
+    expect(described_class.tainting_stubs_enabled).to eq(true)
+
+  end
 end

data/spec/lib/path_reader_spec.rb

@@ -12,9 +12,9 @@ describe Opal::PathReader do
   let(:contents) { File.read(full_path) }
 
   before do
-    path_finder.stub(:find) {|path| nil}
-    path_finder.stub(:find).with(path).and_return(full_path)
-    path_finder.stub(:paths).and_return(Opal.paths)
+    allow(path_finder).to receive(:find) {|path| nil}
+    allow(path_finder).to receive(:find).with(path).and_return(full_path)
+    allow(path_finder).to receive(:paths).and_return(Opal.paths)
   end
 
   include_examples :path_finder

data/spec/lib/spec_helper.rb

@@ -5,12 +5,96 @@ end
 
 require 'opal'
 
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 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'
   config.before { Opal.reset_paths! }
   config.before { Opal::Config.reset! if defined? Opal::Config }
   config.before { Opal::Processor.reset_cache_key! if defined? Opal::Processor }
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+
+    expectations.syntax = [:expect, :should]
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+
+    mocks.syntax = [:expect, :should]
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `||\describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "tmp/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  # config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  # config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  else
+    # The RSpec specs are stored in spec/lib.
+    config.pattern = 'spec/lib/**/*_spec.rb'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
 end

data/spec/lib/sprockets/erb_spec.rb

@@ -19,7 +19,7 @@ describe Opal::ERB::Processor do
   ) }
   let(:required_assets) { [] }
   let(:template) { described_class.new { |t| %Q{<% print("") %><a href="<%= url %>"><%= name %></a>} } }
-  before { sprockets_context.stub(:require_asset) {|asset| required_assets << asset } }
+  before { allow(sprockets_context).to receive(:require_asset) {|asset| required_assets << asset } }
 
   let(:ext) { 'opalerb' }
 

data/spec/lib/sprockets/processor_spec.rb

@@ -45,13 +45,13 @@ describe Opal::Processor do
     let(:config) { Opal::Config }
 
     it 'usually require files' do
-      sprockets_context.should_receive(:require_asset).with(stubbed_file)
+      expect(sprockets_context).to receive(:require_asset).with(stubbed_file)
       template.render(sprockets_context)
     end
 
     it 'skips require of stubbed file' do
       config.stubbed_files << stubbed_file.to_s
-      sprockets_context.should_not_receive(:require_asset).with(stubbed_file)
+      expect(sprockets_context).not_to receive(:require_asset).with(stubbed_file)
       template.render(sprockets_context)
     end
 
@@ -61,7 +61,7 @@ describe Opal::Processor do
       environment.stub(:[]).with('bar.js') { asset }
       environment.stub(:engines) { {'.rb' => described_class, '.opal' => described_class} }
 
-      code = ::Opal::Sprockets.load_asset('bar', environment)
+      code = ::Opal::Sprockets.load_asset('bar')
       code.should match stubbed_file
     end
   end

data/spec/lib/sprockets_spec.rb

@@ -7,21 +7,28 @@ describe Opal::Sprockets do
 
   describe '.load_asset' do
     it 'loads the main asset' do
-      code = described_class.load_asset('console', env)
+      code = described_class.load_asset('console')
       expect(code).to include('Opal.load("console");')
     end
 
     it 'marks as loaded "opal" plus all non opal assets' do
-      code = described_class.load_asset('corelib/runtime', env)
+      code = described_class.load_asset('corelib/runtime')
       expect(code).to include('Opal.loaded(["opal","corelib/runtime"]);')
     end
 
-    it 'returns an empty string if the asset is not found' do
-      code = described_class.load_asset('foo', env)
-      expect(code).to eq('')
+    it 'tries to load an asset if it is registered as opal module' do
+      code = described_class.load_asset('foo')
+      expect(code).to include('if (Opal.modules["foo"]) Opal.load("foo");')
     end
   end
 
+  it 'warns the user that passing an env is not needed, only once' do
+    expect(described_class).to receive(:warn).once
+    described_class.load_asset('foo', env)
+    described_class.load_asset('foo', env)
+    described_class.load_asset('foo', env)
+  end
+
   describe '.javascript_include_tag' do
     it 'works with trailing / in the prefix' do
       code = described_class.javascript_include_tag('corelib/runtime', prefix: '/', sprockets: env, debug: false)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.4
 platform: ruby
 authors:
 - Adam Beynon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-31 00:00:00.000000000 Z
+date: 2017-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sourcemap
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: 3.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: 3.5.0
 - !ruby/object:Gem::Dependency
   name: octokit
   requirement: !ruby/object:Gem::Requirement
@@ -1156,7 +1156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Ruby runtime and core library for JavaScript