opal 1.0.3 → 1.1.1.rc1

data/spec/lib/rewriters/block_to_iter_spec.rb

@@ -0,0 +1,28 @@
+require 'lib/spec_helper'
+
+RSpec.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

@@ -0,0 +1,108 @@
+require 'lib/spec_helper'
+
+RSpec.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(Opal::RewritingError)
+      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(Opal::RewritingError)
+      end
+    end
+  end
+end

data/spec/lib/rewriters/explicit_writer_return_spec.rb

@@ -0,0 +1,186 @@
+require 'lib/spec_helper'
+
+RSpec.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

data/spec/lib/rewriters/for_rewriter_spec.rb

@@ -0,0 +1,92 @@
+require 'lib/spec_helper'
+require 'support/rewriters_helper'
+require 'opal/rewriters/for_rewriter'
+
+RSpec.describe Opal::Rewriters::ForRewriter do
+  include RewritersHelper
+  extend  RewritersHelper
+
+  before(:each) { Opal::Rewriters::ForRewriter.reset_tmp_counter! }
+
+  include_examples 'it rewrites source-to-AST', 'for i in (0..3); for j in (4..6); a = i + j; end; end', s(:begin,
+    s(:lvdeclare, :i),
+    s(:lvdeclare, :j),
+    s(:lvdeclare, :a),
+    s(:send,
+      ast_of('(0..3)'),
+      :each,
+      s(:iter,
+        s(:args,
+          s(:arg, :$for_tmp1)),
+        s(:begin,
+          s(:initialize_iter_arg, :$for_tmp1),
+          s(:lvasgn, :i,
+            s(:js_tmp, :$for_tmp1)),
+          s(:begin,
+            s(:lvdeclare, :j),
+            s(:lvdeclare, :a),
+            s(:send,
+              ast_of('(4..6)'),
+              :each,
+              s(:iter,
+                s(:args,
+                  s(:arg, :$for_tmp2)),
+                s(:begin,
+                  s(:initialize_iter_arg, :$for_tmp2),
+                  s(:lvasgn, :j,
+                    s(:js_tmp, :$for_tmp2)),
+                  s(:lvasgn, :a,
+                    s(:send,
+                      s(:lvar, :i), :+,
+                      s(:lvar, :j)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  include_examples 'it rewrites source-to-AST', 'for i in (0..3); a = 1; b = 2; end', s(:begin,
+    s(:lvdeclare, :i),
+    s(:lvdeclare, :a),
+    s(:lvdeclare, :b),
+    s(:send,
+      ast_of('(0..3)'),
+      :each,
+      s(:iter,
+        s(:args, s(:arg, :$for_tmp1)),
+        s(:begin,
+          s(:initialize_iter_arg, :$for_tmp1),
+          s(:lvasgn, :i, s(:js_tmp, :$for_tmp1)),
+          ast_of('a = 1'),
+          ast_of('b = 2')
+        )
+      )
+    )
+  )
+
+  include_examples 'it rewrites source-to-AST', 'for i, j in obj; a = 1; b, c = 2, 3; end', s(:begin,
+    s(:lvdeclare, :i),
+    s(:lvdeclare, :j),
+    s(:lvdeclare, :a),
+    s(:lvdeclare, :b),
+    s(:lvdeclare, :c),
+    s(:send,
+      ast_of('obj'),
+      :each,
+      s(:iter,
+        s(:args, s(:arg, :$for_tmp1)),
+        s(:begin,
+          s(:initialize_iter_arg, :$for_tmp1),
+          s(:masgn, s(:mlhs, s(:lvasgn, :i), s(:lvasgn, :j)), s(:js_tmp, :$for_tmp1)),
+          ast_of('a = 1'),
+          ast_of('b, c = 2, 3')
+        )
+      )
+    )
+  )
+end

data/spec/lib/rewriters/hashes/key_duplicates_rewriter_spec.rb

@@ -0,0 +1,47 @@
+require 'lib/spec_helper'
+require 'support/rewriters_helper'
+require 'opal/rewriters/hashes/key_duplicates_rewriter'
+
+RSpec.describe Opal::Rewriters::Hashes::KeyDuplicatesRewriter do
+  include RewritersHelper
+
+  shared_examples 'it warns' do |code, key_to_warn|
+    context "for #{code} code" do
+      it "warns about #{key_to_warn.inspect} being overwritten" do
+        expect(Kernel).to receive(:warn).with("warning: key #{key_to_warn.inspect} is duplicated and overwritten")
+
+        ast = parse_without_rewriting(code)
+        rewrite(ast)
+      end
+    end
+  end
+
+  include_examples 'it warns', '{ a: 1, a: 2 }',             :a
+  include_examples 'it warns', '{ a: 1, **{ a: 2 } }',       :a
+  include_examples 'it warns', '{ a: 1, **{ **{ a: 2 } } }', :a
+
+  include_examples 'it warns', '{ "a" => 1, "a" => 2 }',             'a'
+  include_examples 'it warns', '{ "a" => 1, **{ "a" => 2 } }',       'a'
+  include_examples 'it warns', '{ "a" => 1, **{ **{ "a" => 2 } } }', 'a'
+
+  shared_examples 'it does not warn' do |code|
+    context "for #{code} code" do
+      it "does not warn anything" do
+        expect(Kernel).to_not receive(:warn).with(/is duplicated and overwritten/)
+
+        ast = parse_without_rewriting(code)
+        rewrite(ast)
+      end
+    end
+  end
+
+  include_examples 'it does not warn', '{ a: 1 }'
+  include_examples 'it does not warn', '{ a: 1, "a" => 2 }'
+  include_examples 'it does not warn', '{ "a" => 1, a: 2 }'
+  include_examples 'it does not warn', '{ a: 1, **{ "a" => 2 } }'
+  include_examples 'it does not warn', '{ "a" => 1, **{ a: 2 } }'
+  include_examples 'it does not warn', '{ a: 1, nested: { a: 2 } }'
+
+  include_examples 'it does not warn', 'key = "key"; { "#{key}" => 1, "#{key}" => 2 }'
+  include_examples 'it does not warn', 'key = "key"; { :"#{key}" => 1, :"#{key}" => 2 }'
+end