opal 0.11.0.rc1 → 0.11.0

data/spec/lib/rewriters/js_reserved_words_spec.rb

@@ -1,116 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Rewriters::JsReservedWords do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  def expect_rewritten(sexp)
-    processed = Opal::Rewriters::JsReservedWords.new.process(sexp)
-    expect(processed)
-  end
-
-  def expect_no_rewriting_for(sexp)
-    expect_rewritten(sexp).to eq(sexp)
-  end
-
-  reserved_lvars = %i(
-    do if in for let new try var case else enum eval false
-    null this true void with break catch class const super
-    throw while yield delete export import public return
-    static switch typeof default extends finally package
-    private continue debugger function arguments interface
-    protected implements instanceof
-
-    int byte char goto long final float short double native
-    throws boolean abstract volatile transient synchronized
-
-    NaN Infinity undefined
-  )
-
-  reserved_ivars = %i(
-    @constructor @displayName
-    @hasOwnProperty @valueOf
-    @__proto__ @__parent__
-    @__noSuchMethod__ @__count__
-  )
-
-  context 'reserved lvars' do
-    reserved_lvars.each do |lvar_name|
-      context 'as lvars' do
-        it "appends '$'" do
-          expect_rewritten(
-            s(:lvar, lvar_name)
-          ).to eq(
-            s(:lvar, :"#{lvar_name}$")
-          )
-
-          expect_rewritten(
-            s(:lvasgn, lvar_name, s(:int, 1))
-          ).to eq(
-            s(:lvasgn, :"#{lvar_name}$", s(:int, 1))
-          )
-        end
-      end
-
-      context 'as arguments' do
-        it "appends '$'" do
-          [:arg, :restarg, :blockarg, :shadowarg, :kwarg, :kwrestarg].each do |type|
-            expect_rewritten(
-              s(type, lvar_name)
-            ).to eq(
-              s(type, :"#{lvar_name}$")
-            )
-          end
-
-          [:optarg, :kwoptarg].each do |type|
-            expect_rewritten(
-              s(type, lvar_name, s(:nil))
-            ).to eq(
-              s(type, :"#{lvar_name}$", s(:nil))
-            )
-          end
-        end
-      end
-    end
-  end
-
-  context 'reserved ivars' do
-    reserved_ivars.each do |ivar_name|
-      it "appends '$' to :ivar #{ivar_name}" do
-        expect_rewritten(
-          s(:ivar, ivar_name)
-        ).to eq(
-          s(:ivar, :"#{ivar_name}$")
-        )
-      end
-
-      it "appends '$' to :ivasgn #{ivar_name}" do
-        expect_rewritten(
-          s(:ivasgn, ivar_name, s(:nil))
-        ).to eq(
-          s(:ivasgn, :"#{ivar_name}$", s(:nil))
-        )
-      end
-    end
-  end
-
-  context 'normal lvar name' do
-    it 'does not modify AST' do
-      expect_no_rewriting_for(s(:lvar, :a))
-      expect_no_rewriting_for(s(:lvasgn, :a))
-    end
-  end
-
-  context 'normal ivar name' do
-    it 'does not modify AST' do
-      [:arg, :restarg, :blockarg, :shadowarg, :kwarg, :kwrestarg].each do |type|
-        expect_no_rewriting_for(s(type, :a))
-      end
-
-      [:optarg, :kwoptarg].each do |type|
-        expect_no_rewriting_for(s(type, :a, s(:nil)))
-      end
-    end
-  end
-end

data/spec/lib/rewriters/logical_operator_assignment_spec.rb

@@ -1,202 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Rewriters::LogicalOperatorAssignment do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::LogicalOperatorAssignment.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::LogicalOperatorAssignment.reset_tmp_counter!
-    Opal::Rewriter.disable { e.run }
-  end
-  let(:cache_tmp_name) { :$logical_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 = local; a ||= 1', 'a = local; a = a || 1'
-      include_examples 'it rewrites', 'a = local; a &&= 1', 'a = local; a = a && 1'
-    end
-
-    context 'instance variable' do
-      include_examples 'it rewrites', '@a ||= 1', '@a = @a || 1'
-      include_examples 'it rewrites', '@a &&= 1', '@a = @a && 1'
-    end
-
-    context 'constant' do
-      include_examples 'it rewrites', 'CONST ||= 1', 'CONST = CONST || 1'
-      include_examples 'it rewrites', 'CONST &&= 1', 'CONST = CONST && 1'
-    end
-
-    context 'global variable' do
-      include_examples 'it rewrites', '$g ||= 1', '$g = $g || 1'
-      include_examples 'it rewrites', '$g &&= 1', '$g = $g && 1'
-    end
-
-    context 'class variable' do
-      include_examples 'it rewrites', '@@a ||= 1', '@@a = @@a || 1'
-      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'
-      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'
-      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'
-
-      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(:or,
-            s(:send, cached, :b),                       # cached.b
-            s(:send, cached, :b=, parse('rhs'))))       # cached.b = rhs
-
-        expect(rewritten).to eq(expected)
-      end
-
-      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(:and,
-            s(:send, cached, :b),                       # cached.b
-            s(:send, cached, :b=, parse('rhs'))))       # cached.b = 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(:or,
-              s(:send, cached, :meth),                #   cached.meth ||
-              s(:send, cached, :meth=, parse('rhs'))) #     cached.meth = rhs
-            )                                         # end
-          )
-
-        expect(rewritten).to eq(expected)
-      end
-
-      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(:and,
-              s(:send, cached, :meth),                #   cached.meth ||
-              s(:send, cached, :meth=, parse('rhs'))) #     cached.meth = 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"'
-      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")
-      include_examples 'it rewrites', 'defined?(@a &&= 1)', %q("assignment")
-    end
-
-    context 'constant' do
-      include_examples 'it rewrites', 'defined?(CONST ||= 1)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(CONST &&= 1)', %q("assignment")
-    end
-
-    context 'global variable' do
-      include_examples 'it rewrites', 'defined?($g ||= 1)', %q("assignment")
-      include_examples 'it rewrites', 'defined?($g &&= 1)', %q("assignment")
-    end
-
-    context 'class variable' do
-      include_examples 'it rewrites', 'defined?(@@a ||= 1)', %q("assignment")
-      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")
-      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")
-      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")
-      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")
-      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")
-      include_examples 'it rewrites', 'defined?(recvr&.meth &&= rhs)', %q("assignment")
-    end
-  end
-end

data/spec/lib/rewriters/opal_engine_check_spec.rb

@@ -1,82 +0,0 @@
-require 'lib/spec_helper'
-
-describe Opal::Rewriters::OpalEngineCheck do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::OpalEngineCheck.new }
-
-  def expect_rewritten(node)
-    processed = rewriter.process(node)
-    expect(processed)
-  end
-
-  def expect_no_rewriting_for(node)
-    expect_rewritten(node).to eq(node)
-  end
-
-  let(:opal_str_sexp) { s(:str, 'opal') }
-  let(:true_branch) { s(:int, 1) }
-  let(:false_branch) { s(:int, 2) }
-
-  [:RUBY_ENGINE, :RUBY_PLATFORM].each do |const_name|
-    let(:ruby_const_sexp) { s(:const, nil, const_name) }
-
-    context "#{const_name} == rhs" do
-      context "when rhs == 'opal'" do
-        let(:check) do
-          s(:send, ruby_const_sexp, :==, opal_str_sexp)
-        end
-
-        it 'replaces true branch with s(:nil)' do
-          expect_rewritten(
-            s(:if, check, true_branch, false_branch)
-          ).to eq(
-            s(:if, check, true_branch, s(:nil))
-          )
-        end
-      end
-
-      context "when rhs != 'opal'" do
-        let(:check) do
-          s(:send, ruby_const_sexp, :==, s(:nil))
-        end
-
-        it 'does not modify sexp' do
-          expect_no_rewriting_for(
-            s(:if, check, true_branch, false_branch)
-          )
-        end
-      end
-    end
-
-    context "#{const_name} != rhs" do
-      context "when rhs == 'opal'" do
-        let(:check) do
-          s(:send, ruby_const_sexp, :!=, opal_str_sexp)
-        end
-
-        it 'replaces true branch with s(:nil)' do
-          expect_rewritten(
-            s(:if, check, true_branch, false_branch)
-          ).to eq(
-            s(:if, check, s(:nil), false_branch)
-          )
-        end
-      end
-
-      context "when rhs != 'opal'" do
-        let(:check) do
-          s(:send, ruby_const_sexp, :!=, s(:nil))
-        end
-
-        it 'does not modify sexp' do
-          expect_no_rewriting_for(
-            s(:if, check, true_branch, false_branch)
-          )
-        end
-      end
-    end
-  end
-end

data/spec/lib/rewriters/rubyspec/filters_rewriter_spec.rb

@@ -1,53 +0,0 @@
-require 'lib/spec_helper'
-require 'opal/rewriters/rubyspec/filters_rewriter'
-require 'support/rewriters_helper'
-
-describe Opal::Rubyspec::FiltersRewriter do
-  include RewritersHelper
-
-  let(:source) do
-    <<-SOURCE
-      describe 'User#email' do
-        context 'when this' do
-          it 'does that'
-        end
-
-        it 'also does something else'
-      end
-    SOURCE
-  end
-
-  let(:ast) { ast_of(source) }
-
-  context 'when spec is filtered' do
-    around(:each) do |e|
-      Opal::Rubyspec::FiltersRewriter.filter 'User#email when this does that'
-      e.run
-      Opal::Rubyspec::FiltersRewriter.clear_filters!
-    end
-
-    let(:rewritten_source) do
-      <<-SOURCE
-        describe 'User#email' do
-          context 'when this' do
-            nil # <- right here
-          end
-
-          it 'also does something else'
-        end
-      SOURCE
-    end
-
-    let(:expected_ast) { ast_of(rewritten_source) }
-
-    it 'replaces it with nil' do
-      expect_rewritten(ast).to eq(expected_ast)
-    end
-  end
-
-  context 'when spec is not filtered' do
-    it 'does not rewrite it' do
-      expect_no_rewriting_for(ast)
-    end
-  end
-end