opal 0.11.0.rc1 → 0.11.0

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

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

data/spec/lib/fixtures/file_with_directives.js

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

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

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

data/spec/lib/fixtures/no_requires.rb

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

data/spec/lib/fixtures/opal_file.rb

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

data/spec/lib/fixtures/require_tree_test.rb

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

data/spec/lib/fixtures/required_file.js

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

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

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

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

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

data/spec/lib/fixtures/requires.rb

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

data/spec/lib/fixtures/source_location_test.rb

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

data/spec/lib/fixtures/source_map.rb

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

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

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

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

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

data/spec/lib/fixtures/sprockets_require_tree_test.rb

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

data/spec/lib/hike_path_finder_spec.rb

@@ -1,23 +0,0 @@
-require 'lib/spec_helper'
-require 'lib/shared/path_finder_shared'
-require 'opal/hike_path_finder'
-
-describe Opal::HikePathFinder do
-  subject(:path_finder) { described_class.new(root) }
-  let(:root) { File.expand_path('..', __FILE__) }
-  let(:path) { 'fixtures/opal_file' }
-  let(:full_path) { File.join(root, path + ext) }
-  let(:ext) { '.rb' }
-
-  include_examples :path_finder
-
-  context 'with absolute paths' do
-    it 'returns the path if exists' do
-      expect(path_finder.find(full_path)).to eq(full_path)
-    end
-
-    it 'gives nil if it is missing' do
-      expect(path_finder.find(full_path+'/not-real')).to eq(nil)
-    end
-  end
-end

data/spec/lib/path_reader_spec.rb

@@ -1,36 +0,0 @@
-require 'lib/spec_helper'
-require 'lib/shared/path_reader_shared'
-require 'lib/shared/path_finder_shared'
-require 'opal/path_reader'
-
-
-describe Opal::PathReader do
-  subject(:file_reader) { described_class.new(path_finder) }
-  let(:path_finder) { double('path_finder') }
-  let(:path) { 'opal_file' }
-  let(:full_path) { File.expand_path('../fixtures/opal_file.rb', __FILE__) }
-  let(:contents) { File.read(full_path) }
-
-  before do
-    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
-  include_examples :path_reader do
-    let(:path_reader) { file_reader }
-
-    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/shared/path_reader_shared.rb')).not_to be_nil
-    end
-
-    it 'works with absolute paths' do
-      expect(path_reader.read("../#{File.basename(Dir.pwd)}/spec/lib/shared/path_reader_shared.rb")).not_to be_nil
-    end
-  end
-end

data/spec/lib/paths_spec.rb

@@ -1,18 +0,0 @@
-require 'lib/spec_helper'
-
-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/rewriters/binary_operator_assignment_spec.rb

@@ -1,151 +0,0 @@
-require 'lib/spec_helper'
-
-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 = ::Parser::Source::Buffer.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'))))
-      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

data/spec/lib/rewriters/block_to_iter_spec.rb

@@ -1,28 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Rewriters::BlockToIter do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::BlockToIter.new }
-
-  let(:block_node) do
-    # m { |arg1| 1 }
-    s(:block,
-      s(:send, nil, :m),
-      s(:args, s(:arg, :arg1)),
-      s(:int, 1)
-    )
-  end
-
-  let(:iter_node) do
-    s(:send, nil, :m,
-      s(:iter, s(:args, s(:arg, :arg1)), s(:int, 1))
-    )
-  end
-
-  it 'rewriters s(:block) to s(:iter)' do
-    expect(rewriter.process(block_node)).to eq(iter_node)
-  end
-end

data/spec/lib/rewriters/dot_js_syntax_spec.rb

@@ -1,108 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Rewriters::DotJsSyntax do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::DotJsSyntax.new }
-
-  context '.JS. syntax' do
-    let(:send_node) do
-      # a.JS.b(1)
-      s(:send,
-        s(:send, s(:lvar, :a), :JS),
-        :b,
-        s(:int, 1)
-      )
-    end
-
-    let(:dot_js_node) do
-      s(:jscall, s(:lvar, :a), :b, s(:int, 1))
-    end
-
-    it 'rewrites s(:send, s(:send, obj, :JS), :js_method, ...) to s(:jscall, obj, :js_method, ...)' do
-      expect(rewriter.process(send_node)).to eq(dot_js_node)
-    end
-  end
-
-  context '.JS[] syntax' do
-    context 'when passed one argument' do
-      let(:send_node) do
-        # a.JS[1, 2]
-        s(:send,
-          s(:send, s(:lvar, :a), :JS),
-          :[],
-          s(:int, 1)
-        )
-      end
-
-      let(:jsattr_node) do
-        s(:jsattr, s(:lvar, :a), s(:int, 1))
-      end
-
-      it 'rewrites s(:send, s(:send, obj, :JS), :[], arg) to s(:jsattr, obj, arg)' do
-        expect(rewriter.process(send_node)).to eq(jsattr_node)
-      end
-    end
-
-    context 'when passed 1+ arguments' do
-      let(:send_node) do
-        # a.JS[1, 2]
-        s(:send,
-          s(:send, s(:lvar, :a), :JS),
-          :[],
-          s(:int, 1),
-          s(:int, 2)
-        )
-      end
-
-      it 'raises syntax error' do
-        expect {
-          rewriter.process(send_node)
-        }.to raise_error(SyntaxError)
-      end
-    end
-  end
-
-  context '.JS[]= syntax' do
-    context 'when passed two arguments' do
-      let(:send_node) do
-        # a.JS[1] = 2
-        s(:send,
-          s(:send, s(:lvar, :a), :JS),
-          :[]=,
-          s(:int, 1),
-          s(:int, 2)
-        )
-      end
-
-      let(:jsattr_asgn_node) do
-        s(:jsattrasgn, s(:lvar, :a), s(:int, 1), s(:int, 2))
-      end
-
-      it 'converts send node to jsattrasgn' do
-        expect(rewriter.process(send_node)).to eq(jsattr_asgn_node)
-      end
-    end
-
-    context 'when passed 2+ arguments' do
-      let(:send_node) do
-        # a.JS[1, 2] = 3
-        s(:send,
-          s(:send, s(:lvar, :a), :JS),
-          :[]=,
-          s(:int, 1),
-          s(:int, 2),
-          s(:int, 3)
-        )
-      end
-
-      it 'raises syntax error' do
-        expect {
-          rewriter.process(send_node)
-        }.to raise_error(SyntaxError)
-      end
-    end
-  end
-end

data/spec/lib/rewriters/explicit_writer_return_spec.rb

@@ -1,186 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Rewriters::ExplicitWriterReturn do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::ExplicitWriterReturn.new }
-  let(:processed) { rewriter.process(input) }
-
-  def expect_rewritten(sexp)
-    processed = rewriter.process(sexp)
-    expect(processed)
-  end
-
-  def expect_no_rewriting_for(sexp)
-    expect_rewritten(sexp).to eq(sexp)
-  end
-
-  let(:receiver) do
-    # self.a
-    s(:send, nil, :a)
-  end
-
-  let(:single_argument) do
-    # self.c
-    s(:send, nil, :c)
-  end
-
-  let(:multiple_arguments) do
-    # [self.d, self.e]
-    s(:array,
-      s(:send, nil, :d),
-      s(:send, nil, :e)
-    )
-  end
-
-  let(:constant_returner) do
-    # $writer[$writer.length - 1]
-    s(:jsattr,
-      s(:lvar, "$writer"),
-      s(:send, s(:jsattr, s(:lvar, "$writer"), s(:str, "length")), :-, s(:int, 1))
-    )
-  end
-
-  shared_examples 'always returns a temporary argument' do
-    it 'returns a temporary argument' do
-      expect(processed.children[2]).to eq(constant_returner)
-    end
-  end
-
-  describe 'rewriting a.b = c' do
-    let(:input) do
-      s(:send, receiver, :b=, single_argument)
-    end
-
-    it 'generates a temporary argument for a method argument' do
-      expect(processed.children[0]).to eq(
-        s(:lvasgn, "$writer", s(:array, single_argument))
-      )
-    end
-
-    it 'calls receiver with this temporary argument as a splat' do
-      expect(processed.children[1]).to eq(
-        s(:send, receiver, :b=,
-          s(:splat, s(:lvar, "$writer"))
-        )
-      )
-    end
-
-    include_examples 'always returns a temporary argument'
-  end
-
-  describe 'rewriting a.b = c, d' do
-    let(:input) do
-      s(:send, receiver, :b=, multiple_arguments)
-    end
-
-    it 'generates a temporary argument for array of method arguments' do
-      expect(processed.children[0]).to eq(
-        s(:lvasgn, "$writer", s(:array, multiple_arguments))
-      )
-    end
-
-    it 'calls receiver with this temporary argument as a splat' do
-      expect(processed.children[1]).to eq(
-        s(:send, receiver, :b=,
-          s(:splat, s(:lvar, "$writer"))
-        )
-      )
-    end
-
-    include_examples 'always returns a temporary argument'
-  end
-
-  describe "[]= method" do
-    let(:idx) { s(:send, nil, :b) }
-
-    describe 'rewriting a[b] = c' do
-      let(:input) do
-        s(:send, receiver, :[]=, idx, single_argument)
-      end
-
-      it 'generates a temporary argument for all passed method arguments' do
-        expect(processed.children[0]).to eq(
-          s(:lvasgn, "$writer", s(:array, idx, single_argument))
-        )
-      end
-
-      it 'calls receiver with this temporary argument as a splat' do
-        expect(processed.children[1]).to eq(
-          s(:send, receiver, :[]=,
-            s(:splat, s(:lvar, "$writer"))
-          )
-        )
-      end
-
-      include_examples 'always returns a temporary argument'
-    end
-
-    describe 'rewriting a[b] = c, d' do
-      let(:input) do
-        s(:send, receiver, :[]=, idx, multiple_arguments)
-      end
-
-      it 'generates a temporary argument for array of method arguments' do
-        expect(processed.children[0]).to eq(
-          s(:lvasgn, "$writer", s(:array, idx, multiple_arguments))
-        )
-      end
-
-      it 'calls receiver with this temporary argument as a splat' do
-        expect(processed.children[1]).to eq(
-          s(:send, receiver, :[]=,
-            s(:splat, s(:lvar, "$writer"))
-          )
-        )
-      end
-
-      include_examples 'always returns a temporary argument'
-    end
-  end
-
-  describe 'mass assignment' do
-    let(:input) do
-      # a, b = c, d
-      s(:masgn,
-        s(:mlhs,
-          s(:lvasgn, :a),
-          s(:lvasgn, :b)),
-        s(:array,
-          s(:send, nil, :c),
-          s(:send, nil, :d)))
-    end
-
-    it 'does not affect it' do
-      expect_no_rewriting_for(input)
-    end
-  end
-
-  describe '.JS. syntax' do
-    let(:input) do
-      # a.JS.b = c
-      s(:jscall,
-        s(:send, nil, :a), :b=,
-        s(:send, nil, :c))
-    end
-
-    it 'does not affect it' do
-      expect_no_rewriting_for(input)
-    end
-  end
-
-  describe '.JS[] syntax' do
-    let(:input) do
-      s(:jsattrasgn,
-        s(:send, nil, :a),
-        s(:sym, :b),
-        s(:send, nil, :c))
-    end
-
-    it 'does not affect it' do
-      expect_no_rewriting_for(input)
-    end
-  end
-end