opal 1.0.1 → 1.1.0.rc1

data/spec/lib/config_spec.rb

@@ -0,0 +1,112 @@
+require 'lib/spec_helper'
+require 'opal/config'
+
+RSpec.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.dynamic_require_severity).to eq(:warning)
+    expect(described_class.missing_require_severity).to eq(:error)
+    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.dynamic_require_severity = :foobar }.to raise_error(ArgumentError)
+    expect{ described_class.missing_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.missing_require_severity = :error }.not_to raise_error
+    expect(described_class.missing_require_severity).to eq(:error)
+
+    expect{ described_class.missing_require_severity = :ignore }.not_to raise_error
+    expect(described_class.missing_require_severity).to eq(:ignore)
+
+    expect{ described_class.missing_require_severity = :warning }.not_to raise_error
+    expect(described_class.missing_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)
+  end
+end

data/spec/lib/dependency_resolver_spec.rb

@@ -0,0 +1,43 @@
+require 'lib/spec_helper'
+
+RSpec.describe Opal::Nodes::CallNode::DependencyResolver do
+  let(:compiler) { double(:compiler, dynamic_require_severity: :warning) }
+
+  it "resolves simple strings to themselves" do
+    expect(resolve s(:str, 'foo')).to eq('foo')
+  end
+
+  context "using a dynamic segment not supported" do
+    it "raises a compiler error when severity is :error" do
+      compiler = double(:compiler, dynamic_require_severity: :error)
+      expect(compiler).to     receive(:dynamic_require_severity).once
+      expect(compiler).not_to receive(:warning)
+      expect(compiler).to     receive(:error).once
+      described_class.new(compiler, s(:self)).resolve
+    end
+
+    it "produces a compiler warning when severity is :warning" do
+      compiler = double(:compiler, dynamic_require_severity: :warning)
+      expect(compiler).to     receive(:dynamic_require_severity).once
+      expect(compiler).to     receive(:warning).once
+      expect(compiler).not_to receive(:error)
+      described_class.new(compiler, s(:self)).resolve
+    end
+
+    it "does not produce a warning when severity is :ignore" do
+      compiler = double(:compiler, dynamic_require_severity: :ignore)
+      expect(compiler).to     receive(:dynamic_require_severity).once
+      expect(compiler).not_to receive(:warning)
+      expect(compiler).not_to receive(:error)
+      described_class.new(compiler, s(:self)).resolve
+    end
+  end
+
+  def s(type, *children)
+    ::Opal::AST::Node.new(type, children)
+  end
+
+  def resolve(sexp)
+    described_class.new(compiler, sexp).resolve
+  end
+end

data/spec/lib/deprecations_spec.rb

@@ -0,0 +1,17 @@
+require 'lib/spec_helper'
+require 'opal/deprecations'
+
+RSpec.describe Opal::Deprecations do
+  subject { Object.new.extend described_class }
+
+  it 'defaults to warn' do
+    expect(subject).to receive(:warn)
+    subject.deprecation "there's a new api!"
+  end
+
+  it 'can be set to raise' do
+    subject.raise_on_deprecation = true
+    expect(subject).to receive(:raise)
+    subject.deprecation "there's a new api!"
+  end
+end

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

@@ -0,0 +1,4 @@
+#= require no_requires
+//= require jst_file
+#= require_tree ./required_tree_test
+require 'file_with_directives'

data/spec/lib/fixtures/file_with_directives.js

@@ -0,0 +1,2 @@
+//= require required_file
+console.log('file with directives');

data/spec/lib/fixtures/jst_file.js.jst

@@ -0,0 +1 @@
+#= require sprockets_file

data/spec/lib/fixtures/no_requires.rb

@@ -0,0 +1 @@
+puts 'hi there'

data/spec/lib/fixtures/opal_file.rb

@@ -0,0 +1,2 @@
+require 'opal'
+puts 'hi from opal!'

data/spec/lib/fixtures/require_tree_test.rb

@@ -0,0 +1,3 @@
+require_tree '../fixtures/required_tree_test'
+
+puts 5

data/spec/lib/fixtures/required_file.js

@@ -0,0 +1 @@
+console.log('required file');

data/spec/lib/fixtures/required_tree_test/required_file1.rb

@@ -0,0 +1 @@
+p 1

data/spec/lib/fixtures/required_tree_test/required_file2.rb

@@ -0,0 +1 @@
+p 2

data/spec/lib/fixtures/requires.rb

@@ -0,0 +1,7 @@
+require 'foo'
+
+puts 'hello'
+
+require 'bar'
+
+puts 'goodbye'

data/spec/lib/fixtures/source_location_test.rb

@@ -0,0 +1,7 @@
+
+
+
+# Do not move this method
+# This file is used to test Method#source_location
+def m
+end

data/spec/lib/fixtures/source_map.rb

@@ -0,0 +1 @@
+puts 'smap!'

data/spec/lib/fixtures/source_map/subfolder/other_file.rb

@@ -0,0 +1 @@
+puts 'other!'

data/spec/lib/fixtures/sprockets_file.js.rb

@@ -0,0 +1,3 @@
+require 'opal'
+require 'native'
+puts 'sprockets!'

data/spec/lib/fixtures/sprockets_require_tree_test.rb

@@ -0,0 +1,3 @@
+#=require_tree ./required_tree_test
+
+puts 5

data/spec/lib/path_reader_spec.rb

@@ -0,0 +1,47 @@
+require 'lib/spec_helper'
+require 'opal/path_reader'
+
+RSpec.describe Opal::PathReader do
+  subject(:path_reader) { described_class.new }
+  let(:path) { 'opal_file' }
+  let(:full_path) { File.expand_path('../fixtures/opal_file.rb', __FILE__) }
+  let(:contents) { File.read(full_path, mode: "rb:UTF-8") }
+
+  before do
+    allow_any_instance_of(Opal::Hike::Trail).to receive(:find) {|path| nil}
+    allow_any_instance_of(Opal::Hike::Trail).to receive(:find).with(path).and_return(full_path)
+  end
+
+  describe '#paths' do
+    it 'is an Enumberable' do
+      expect(path_reader.paths).to be_an(Enumerable)
+    end
+
+    it 'includes Opal.paths' do
+      paths = path_reader.paths.to_a
+      Opal.paths.each { |path| expect(paths).to include(path) }
+    end
+  end
+
+  describe '#read' do
+    it 'reads the contents from the path' do
+      expect(path_reader.read(path)).to eq(contents)
+    end
+
+    it 'returns nil if the file is missing' do
+      expect(path_reader.read('unexpected-path!')).to be_nil
+    end
+  end
+
+  it 'works with absolute paths' do
+    expect(path_reader.read(File.expand_path(__FILE__))).not_to be_nil
+  end
+
+  it 'works with relative paths starting with ./' do
+    expect(path_reader.read('./spec/lib/spec_helper.rb')).not_to be_nil
+  end
+
+  it 'works with absolute paths' do
+    expect(path_reader.read("../#{File.basename(Dir.pwd)}/spec/lib/spec_helper.rb")).not_to be_nil
+  end
+end

data/spec/lib/paths_spec.rb

@@ -0,0 +1,18 @@
+require 'lib/spec_helper'
+
+RSpec.describe 'Opal.use_gem' do
+  # Coverage probably should be improved
+
+  it 'adds require_paths of a gem to Opal paths' do
+    begin
+      Opal.use_gem 'rake'
+    rescue Opal::GemNotFound => e
+      raise(e) unless e.gem_name == 'rake'
+      skip %(Will fail if GEM_HOME has "rake" in the path, that's ok)
+    end
+
+    added_rake_paths = Opal.paths.grep(/rake/)
+    expect(added_rake_paths.size).to eq(1)
+    expect(added_rake_paths.first).to match(%r{/rake-[\d\.]+/lib$})
+  end
+end

data/spec/lib/repl_spec.rb

@@ -0,0 +1,28 @@
+require 'lib/spec_helper'
+require 'opal/repl'
+
+RSpec.describe Opal::REPL, skip: RUBY_PLATFORM != 'ruby' do
+  describe '#eval_ruby' do
+    let(:input_and_output) { {
+      'puts 5'          => "5\n=> nil\n",
+      'a = 1'           => "=> 1\n",
+      'a += 1'          => "=> 2\n",
+      'a + 3'           => "=> 5\n",
+      'puts a + 3'      => "5\n=> nil\n",
+      '"#{a} + 3"'      => "=> \"2 + 3\"\n",
+      'puts "#{a} + 3"' => "2 + 3\n=> nil\n",
+    } }
+
+    subject(:repl) { described_class.new }
+
+    it 'evaluates user inputs' do
+      repl.load_opal
+
+      input_and_output.each do |input, output|
+        expect { repl.run_line(input) }.to output(output).to_stdout
+      end
+
+      repl.finish
+    end
+  end
+end

data/spec/lib/rewriters/base_spec.rb

@@ -0,0 +1,68 @@
+require 'lib/spec_helper'
+require 'support/rewriters_helper'
+require 'opal/rewriters/base'
+
+RSpec.describe Opal::Rewriters::Base do
+  include RewritersHelper
+
+  def body_ast_of(method_source)
+    def_ast = parse_without_rewriting(method_source)
+    _, _, body_ast = *def_ast
+    body_ast
+  end
+
+  let(:node) { ast_of('INJECTED') } # s(:const, nil, :INJECTED)
+  let(:rewriter) { described_class.new }
+
+  describe '#prepend_to_body' do
+    context 'for empty body' do
+      it 'replaces body with provided node' do
+        body = body_ast_of('def m(a); end')
+        rewritten = rewriter.prepend_to_body(body, node)
+        expect(rewritten).to eq(body_ast_of('def m; INJECTED; end'))
+      end
+    end
+
+    context 'for single-line body' do
+      it 'prepends a node to the body and wraps it with begin; end' do
+        body = body_ast_of('def m; 1; end')
+        rewritten = rewriter.prepend_to_body(body, node)
+        expect(rewritten).to eq(body_ast_of('def m; INJECTED; 1; end'))
+      end
+    end
+
+    context 'for multi-line body' do
+      it 'prepends a node to the body' do
+        body = body_ast_of('def m(a); 1; 2; end')
+        rewritten = rewriter.prepend_to_body(body, node)
+        expect(rewritten).to eq(body_ast_of('def m; INJECTED; 1; 2; end'))
+      end
+    end
+  end
+
+  describe '#append_to_body' do
+    context 'for empty body' do
+      it 'replaces body with provided node' do
+        body = body_ast_of('def m(a); end')
+        rewritten = rewriter.append_to_body(body, node)
+        expect(rewritten).to eq(body_ast_of('def m; INJECTED; end'))
+      end
+    end
+
+    context 'for single-line body' do
+      it 'appends a node to the body and wraps it with begin; end' do
+        body = body_ast_of('def m(a); 1; end')
+        rewritten = rewriter.append_to_body(body, node)
+        expect(rewritten).to eq(body_ast_of('def m; 1; INJECTED; end'))
+      end
+    end
+
+    context 'for multi-line body' do
+      it 'appends a node to the body' do
+        body = body_ast_of('def m(a); 1; 2; end')
+        rewritten = rewriter.append_to_body(body, node)
+        expect(rewritten).to eq(body_ast_of('def m; 1; 2; INJECTED; end'))
+      end
+    end
+  end
+end

data/spec/lib/rewriters/binary_operator_assignment_spec.rb

@@ -0,0 +1,153 @@
+require 'lib/spec_helper'
+
+RSpec.describe Opal::Rewriters::BinaryOperatorAssignment do
+  def s(type, *children)
+    ::Opal::AST::Node.new(type, children)
+  end
+
+  let(:rewriter) { Opal::Rewriters::BinaryOperatorAssignment.new }
+
+  def parse(source)
+    parser = Opal::Parser.default_parser
+    buffer = ::Opal::Parser::SourceBuffer.new('(eval)')
+    buffer.source = source
+    parser.parse(buffer)
+  end
+
+  def rewrite(ast)
+    rewriter.process(ast)
+  end
+
+  around(:each) do |e|
+    Opal::Rewriters::BinaryOperatorAssignment.reset_tmp_counter!
+    Opal::Rewriter.disable { e.run }
+  end
+  let(:cache_tmp_name) { :$binary_op_recvr_tmp_1 }
+  let(:cached) { s(:js_tmp, cache_tmp_name) }
+
+  shared_examples 'it rewrites' do |from, to|
+    it "rewrites #{from.inspect} to #{to.inspect}" do
+      input = parse(from)
+      rewritten = rewrite(input)
+      expected = parse(to)
+
+      expect(rewritten).to eq(expected)
+    end
+  end
+
+  context 'rewriting or_asgn and and_asgn nodes' do
+    context 'local variable' do
+      include_examples 'it rewrites', 'a = 1; a += 2', 'a = 1; a = a + 2'
+    end
+
+    context 'instance variable' do
+      include_examples 'it rewrites', '@a += 1', '@a = @a + 1'
+    end
+
+    context 'constant' do
+      include_examples 'it rewrites', 'CONST += 1', 'CONST = CONST + 1'
+    end
+
+    context 'global variable' do
+      include_examples 'it rewrites', '$g += 1', '$g = $g + 1'
+    end
+
+    context 'class variable' do
+      include_examples 'it rewrites', '@@a += 1', '@@a = @@a + 1'
+    end
+
+    context 'simple method call' do
+      include_examples 'it rewrites', 'recvr = 1; recvr.meth += rhs', 'recvr = 1; recvr.meth = recvr.meth + rhs'
+    end
+
+    context '[] / []= method call' do
+      include_examples 'it rewrites', 'recvr = 1; recvr[idx] += rhs', 'recvr = 1; recvr[idx] = recvr[idx] + rhs'
+    end
+
+    context '[] / []= method call with multiple arguments' do
+      include_examples 'it rewrites',
+        'recvr = 1; recvr[idx1, idx2] += rhs',
+          'recvr = 1; recvr[idx1, idx2] = recvr[idx1, idx2] + rhs'
+    end
+
+    context 'chain of method calls' do
+      it 'rewrites += by caching receiver to a temporary local variable' do
+        input = parse('recvr.a.b += rhs')
+        rewritten = rewrite(input)
+
+        expected = s(:begin,
+          s(:lvasgn, cache_tmp_name, parse('recvr.a')), # cached = recvr.a
+          s(:send, cached, :b=,
+            s(:send,
+              s(:send, cached, :b),
+              :+,
+              parse('rhs'))))
+
+        expect(rewritten).to eq(expected)
+      end
+    end
+
+    context 'method call using safe nafigator' do
+      it 'rewrites += by caching receiver and rewriting it to if and or_asgn' do
+        input = parse('recvr&.meth += rhs')
+        rewritten = rewrite(input)
+
+        expected = s(:begin,
+          s(:lvasgn, cache_tmp_name, parse('recvr')), # cached = recvr
+          s(:if, s(:send, cached, :nil?),             # if cached.nil?
+            s(:nil),                                  #   nil
+                                                      # else
+            s(:send, cached, :meth=,                  #   cached.meth =
+              s(:send,
+                s(:send, cached, :meth),              #     cached.meth +
+                :+,
+                parse('rhs')))                        #     rhs
+          ))                                          # end
+
+        expect(rewritten).to eq(expected)
+      end
+    end
+  end
+
+  context 'rewriting defined?(or_asgn) and defined?(and_asgn)' do
+    context 'local variable' do
+      include_examples 'it rewrites', 'a = nil; defined?(a += 1)', 'a = nil; "assignment"'
+    end
+
+    context 'instance variable' do
+      include_examples 'it rewrites', 'defined?(@a += 1)', %q("assignment")
+    end
+
+    context 'constant' do
+      include_examples 'it rewrites', 'defined?(CONST += 1)', %q("assignment")
+    end
+
+    context 'global variable' do
+      include_examples 'it rewrites', 'defined?($g += 1)', %q("assignment")
+    end
+
+    context 'class variable' do
+      include_examples 'it rewrites', 'defined?(@@a += 1)', %q("assignment")
+    end
+
+    context 'simple method call' do
+      include_examples 'it rewrites', 'defined?(recvr.meth += rhs)', %q("assignment")
+    end
+
+    context '[] / []= method call' do
+      include_examples 'it rewrites', 'defined?(recvr[idx] += rhs)', %q("assignment")
+    end
+
+    context '[] / []= method call with multiple arguments' do
+      include_examples 'it rewrites', 'defined?(recvr[idx1, idx2] += rhs)', %q("assignment")
+    end
+
+    context 'chain of method calls' do
+      include_examples 'it rewrites', 'defined?(recvr.a.b.c += rhs)', %q("assignment")
+    end
+
+    context 'method call using safe nafigator' do
+      include_examples 'it rewrites', 'defined?(recvr&.meth += rhs)', %q("assignment")
+    end
+  end
+end