opal 0.10.0 → 0.11.0

data/spec/lib/parser/string_spec.rb

@@ -1,286 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Strings" do
-  it "parses empty strings" do
-    parsed('""').should == [:str, ""]
-    parsed("''").should == [:str, ""]
-  end
-
-  it "parses a simple string without interpolation as s(:str)" do
-    parsed('"foo # { } bar"').should == [:str, "foo # { } bar"]
-  end
-
-  it "does not interpolate with single quotes" do
-    parsed("'\#{foo}'").should == [:str, "\#{foo}"]
-    parsed("'\#@foo'").should == [:str, "\#@foo"]
-    parsed("'\#$foo'").should == [:str, "\#$foo"]
-    parsed("'\#@@foo'").should == [:str, "\#@@foo"]
-  end
-
-  it "supports interpolation with double quotes" do
-    parsed('"#{foo}"').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    parsed('"#@foo"').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
-    parsed('"#$foo"').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
-    parsed('"#@@foo"').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
-  end
-
-  it "allows underscores in ivar, gvar and cvar interpolation" do
-    parsed('"#@foo_bar"').should == [:dstr, "", [:evstr, [:ivar, :@foo_bar]]]
-    parsed('"#$foo_bar"').should == [:dstr, "", [:evstr, [:gvar, :$foo_bar]]]
-    parsed('"#@@foo_bar"').should == [:dstr, "", [:evstr, [:cvar, :@@foo_bar]]]
-  end
-
-  describe "from %Q construction" do
-    it "can use '[', '(', '{' or '<' matching pairs for string boundry" do
-      parsed('%Q{foo}').should == [:str, "foo"]
-      parsed('%Q[foo]').should == [:str, "foo"]
-      parsed('%Q(foo)').should == [:str, "foo"]
-      parsed('%Q<foo>').should == [:str, "foo"]
-    end
-
-    it "can use valid characters as string boundrys" do
-      parsed('%q!Ford!').should == [:str, 'Ford']
-      parsed('%qaForda').should == [:str, 'Ford']
-      parsed('%q?Ford?').should == [:str, 'Ford']
-    end
-
-    it "can parse empty strings" do
-      parsed('%Q{}').should == [:str, ""]
-      parsed('%Q[]').should == [:str, ""]
-      parsed('%Q()').should == [:str, ""]
-    end
-
-    it "should allow interpolation" do
-      parsed('%Q(#{foo})').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%Q[#{foo}]').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%Q{#{foo}}').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    end
-
-    it "should allow ivar, gvar and cvar interpolation" do
-      parsed('%Q{#@foo}').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
-      parsed('%Q{#$foo}').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
-      parsed('%Q{#@@foo}').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
-    end
-
-    it "should match '{' and '}' pairs used to start string before ending match" do
-      parsed('%Q{{}}').should == [:str, "{}"]
-      parsed('%Q{foo{bar}baz}').should == [:str, "foo{bar}baz"]
-      parsed('%Q{{foo}bar}').should == [:str, "{foo}bar"]
-      parsed('%Q{foo{bar}}').should == [:str, "foo{bar}"]
-      parsed('%Q{foo#{bar}baz}').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%Q{a{b{c}d{e}f}g}').should == [:str, "a{b{c}d{e}f}g"]
-      parsed('%Q{a{b{c}#{foo}d}e}').should == [:dstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
-    end
-
-    it "should match '(' and ')' pairs used to start string before ending match" do
-      parsed('%Q(())').should == [:str, "()"]
-      parsed('%Q(foo(bar)baz)').should == [:str, "foo(bar)baz"]
-      parsed('%Q((foo)bar)').should == [:str, "(foo)bar"]
-      parsed('%Q(foo(bar))').should == [:str, "foo(bar)"]
-      parsed('%Q(foo#{bar}baz)').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%Q(a(b(c)d(e)f)g)').should == [:str, "a(b(c)d(e)f)g"]
-      parsed('%Q(a(b(c)#{foo}d)e)').should == [:dstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
-    end
-
-    it "should match '[' and ']' pairs used to start string before ending match" do
-      parsed('%Q[[]]').should == [:str, "[]"]
-      parsed('%Q[foo[bar]baz]').should == [:str, "foo[bar]baz"]
-      parsed('%Q[[foo]bar]').should == [:str, "[foo]bar"]
-      parsed('%Q[foo[bar]]').should == [:str, "foo[bar]"]
-      parsed('%Q[foo#{bar}baz]').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%Q[a[b[c]d[e]f]g]').should == [:str, "a[b[c]d[e]f]g"]
-      parsed('%Q[a[b[c]#{foo}d]e]').should == [:dstr, "a[b[c]", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d]e"]]
-    end
-
-    it "correctly parses block braces within interpolations" do
-      parsed('%Q{#{each { nil } }}').should == [:dstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-    end
-
-    it "parses other Qstrings within interpolations" do
-      parsed('%Q{#{ %Q{} }}').should == [:dstr, "", [:evstr, [:str, ""]]]
-    end
-  end
-
-  describe "from character shortcuts" do
-    it "produces a string sexp" do
-      parsed("?a").should == [:str, "a"]
-      parsed("?&").should == [:str, "&"]
-    end
-
-    it "parses escape sequences" do
-      parsed("?\\n").should == [:str, "\n"]
-      parsed("?\\t").should == [:str, "\t"]
-    end
-
-    it "parses a string sexp as a command arg" do
-      parsed("foo ?a").should == [:call, nil, :foo, [:arglist, [:str, "a"]]]
-    end
-  end
-
-  it "parses %[] strings" do
-    parsed('%[]').should == [:str, '']
-    parsed('%[foo]').should == [:str, 'foo']
-  end
-
-  it "parses %<> strings" do
-    parsed('%<>').should == [:str, '']
-    parsed('%<foo>').should == [:str, 'foo']
-  end
-
-  it "parses %&& strings" do
-    parsed('%&&').should == [:str, '']
-    parsed('%&foo&').should == [:str, 'foo']
-  end
-end
-
-
-describe "x-strings" do
-  it "parses simple xstring as s(:xstr)" do
-    parsed("`foo`").should == [:xstr, "foo"]
-  end
-
-  it "parses new lines within xstring" do
-    parsed("`\nfoo\n\nbar`").should == [:xstr, "\nfoo\n\nbar"]
-  end
-
-  it "allows interpolation within xstring" do
-    parsed('`#{bar}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]]]
-    parsed('`#{bar}#{baz}`').should == [:dxstr, "", [:evstr, [:call, nil, :bar, [:arglist]]], [:evstr, [:call, nil, :baz, [:arglist]]]]
-  end
-
-  it "supports ivar interpolation" do
-    parsed('`#@foo`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
-    parsed('`#@foo.bar`').should == [:dxstr, "", [:evstr, [:ivar, :@foo]], [:str, ".bar"]]
-  end
-
-  it "supports gvar interpolation" do
-    parsed('`#$foo`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
-    parsed('`#$foo.bar`').should == [:dxstr, "", [:evstr, [:gvar, :$foo]], [:str, ".bar"]]
-  end
-
-  it "supports cvar interpolation" do
-    parsed('`#@@foo`').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
-  end
-
-  it "correctly parses block braces within interpolations" do
-    parsed('`#{ each { nil } }`').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-  end
-
-  it "parses xstrings within interpolations" do
-    parsed('`#{ `bar` }`').should == [:dxstr, "", [:evstr, [:xstr, "bar"]]]
-  end
-
-  it "parses multiple levels of interpolation" do
-    parsed('`#{ `#{`bar`}` }`').should == [:dxstr, "", [:evstr, [:dxstr, "", [:evstr, [:xstr, "bar"]]]]]
-  end
-
-  describe "created using %x notation" do
-    it "can use '[', '(' or '{' matching pairs for string boundry" do
-      parsed('%x{foo}').should == [:xstr, "foo"]
-      parsed('%x[foo]').should == [:xstr, "foo"]
-      parsed('%x(foo)').should == [:xstr, "foo"]
-    end
-
-    it "can parse empty strings" do
-      parsed('%x{}').should == [:xstr, ""]
-      parsed('%x[]').should == [:xstr, ""]
-      parsed('%x()').should == [:xstr, ""]
-    end
-
-    it "should allow interpolation" do
-      parsed('%x{#{foo}}').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%x[#{foo}]').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-      parsed('%x(#{foo})').should == [:dxstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
-    end
-
-    it "should allow ivar, gvar and cvar interpolation" do
-      parsed('%x{#@foo}').should == [:dxstr, "", [:evstr, [:ivar, :@foo]]]
-      parsed('%x{#$foo}').should == [:dxstr, "", [:evstr, [:gvar, :$foo]]]
-      parsed('%x{#@@foo}').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
-    end
-
-    it "should match '{' and '}' pairs used to start string before ending match" do
-      parsed('%x{{}}').should == [:xstr, "{}"]
-      parsed('%x{foo{bar}baz}').should == [:xstr, "foo{bar}baz"]
-      parsed('%x{{foo}bar}').should == [:xstr, "{foo}bar"]
-      parsed('%x{foo{bar}}').should == [:xstr, "foo{bar}"]
-      parsed('%x{foo#{bar}baz}').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%x{a{b{c}d{e}f}g}').should == [:xstr, "a{b{c}d{e}f}g"]
-      parsed('%x{a{b{c}#{foo}d}e}').should == [:dxstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
-    end
-
-    it "should match '(' and ')' pairs used to start string before ending match" do
-      parsed('%x(())').should == [:xstr, "()"]
-      parsed('%x(foo(bar)baz)').should == [:xstr, "foo(bar)baz"]
-      parsed('%x((foo)bar)').should == [:xstr, "(foo)bar"]
-      parsed('%x(foo(bar))').should == [:xstr, "foo(bar)"]
-      parsed('%x(foo#{bar}baz)').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%x(a(b(c)d(e)f)g)').should == [:xstr, "a(b(c)d(e)f)g"]
-      parsed('%x(a(b(c)#{foo}d)e)').should == [:dxstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
-    end
-
-    it "should match '[' and ']' pairs used to start string before ending match" do
-      parsed('%x[[]]').should == [:xstr, "[]"]
-      parsed('%x[foo[bar]baz]').should == [:xstr, "foo[bar]baz"]
-      parsed('%x[[foo]bar]').should == [:xstr, "[foo]bar"]
-      parsed('%x[foo[bar]]').should == [:xstr, "foo[bar]"]
-      parsed('%x[foo#{bar}baz]').should == [:dxstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
-      parsed('%x[a[b[c]d[e]f]g]').should == [:xstr, "a[b[c]d[e]f]g"]
-      parsed('%x[a[b[c]#{foo}d]e]').should == [:dxstr, "a[b[c]", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d]e"]]
-    end
-
-    it "correctly parses block braces within interpolations" do
-      parsed('%x{#{each { nil } }}').should == [:dxstr, "", [:evstr, [:call, nil, :each, [:arglist], [:iter, nil, [:nil]]]]]
-    end
-
-    it "parses other Xstrings within interpolations" do
-      parsed('%x{#{ %x{} }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
-      parsed('%x{#{ `` }}').should == [:dxstr, "", [:evstr, [:xstr, ""]]]
-      parsed('%x{#{ `foo` }}').should == [:dxstr, "", [:evstr, [:xstr, "foo"]]]
-    end
-  end
-
-  describe "cannot be created with %X notation" do
-    it "should not parse" do
-      lambda {
-        parsed('%X{}')
-      }.should raise_error(Exception)
-    end
-  end
-
-  describe "contiguous strings" do
-    it "concatenates parts" do
-      parsed('"a" "b"').should == [:dstr, "a", [:str, "b"]]
-    end
-  end
-
-end
-
-describe "Heredocs" do
-
-  it "parses as a s(:str)" do
-    parsed("a = <<-FOO\nbar\nFOO")[2].should == [:str, "bar\n"]
-  end
-
-  it "allows start marker to be wrapped in quotes" do
-    parsed("a = <<-'FOO'\nbar\nFOO")[2].should == [:str, "bar\n"]
-    parsed("a = <<-\"FOO\"\nbar\nFOO")[2].should == [:str, "bar\n"]
-  end
-
-  it "does not parse EOS unless beginning of line" do
-    parsed("<<-FOO\ncontentFOO\nFOO").should == [:str, "contentFOO\n"]
-  end
-
-  it "does not parse EOS unless end of line" do
-    parsed("<<-FOO\nsome FOO content\nFOO").should == [:str, "some FOO content\n"]
-  end
-
-  it "parses postfix code as if it appeared after heredoc" do
-    parsed("<<-FOO.class\ncode\nFOO").should == [:call, [:str, "code\n"], :class, [:arglist]]
-    parsed("bar(<<-FOO, 1, 2, 3)\ncode\nFOO").should == [:call, nil, :bar,
-                                                              [:arglist, [:str, "code\n"],
-                                                                         [:int, 1],
-                                                                         [:int, 2],
-                                                                         [:int, 3]]]
-  end
-end

data/spec/lib/parser/super_spec.rb

@@ -1,20 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The super keyword" do
-  it "should return s(:super) for any arguments" do
-    parsed("super 1").should == [:super, [:arglist, [:int, 1]]]
-    parsed("super 1, 2").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
-    parsed("super 1, *2").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
-  end
-
-  it "should set nil for args when no arguments or parans" do
-    parsed("super").should == [:super, nil]
-  end
-
-  it "should always return s(:super) with :arglist when parans are used" do
-    parsed("super()").should == [:super, [:arglist]]
-    parsed("super(1)").should == [:super, [:arglist, [:int, 1]]]
-    parsed("super(1, 2)").should == [:super, [:arglist, [:int, 1], [:int, 2]]]
-    parsed("super(1, *2)").should == [:super, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
-  end
-end

data/spec/lib/parser/unary_spec.rb

@@ -1,52 +0,0 @@
-require 'support/parser_helpers'
-
-describe Opal::Parser do
-  describe '-@' do
-    context 'with an integer' do
-      it "parses unary op. with the right precedence" do
-        parsed("-1.hello").should == [:call, [:int, -1], :hello, [:arglist]]
-        expected = [:call, [:call, [:int, 1], :**, [:arglist, [:int, 2]]], :-@, [:arglist]]
-        parsed("-1 ** 2").should == expected
-        expected = [:call, nil, :puts, [:arglist, [:call, [:int, -1], :hello, [:arglist]]]]
-        parsed("puts -1.hello").should == expected
-      end
-
-      it "parses unary op. as a method call" do
-        parsed("-1").should == [:int, -1]
-      end
-
-    end
-
-    context 'with a float' do
-      it "parses unary op. with the right precedence" do
-        parsed("-1.23.hello").should == [:call, [:float, -1.23], :hello, [:arglist]]
-      end
-
-      it "parses unary op. as a method call" do
-        parsed("-1.23").should == [:float, -1.23]
-      end
-    end
-  end
-
-  describe '+@' do
-    context 'with an integer' do
-      it "parses unary op. with the right precedence" do
-        parsed("+1.hello").should == [:call, [:int, 1], :hello, [:arglist]]
-      end
-
-      it "parses unary op. as a method call" do
-        parsed("-1").should == [:int, -1]
-      end
-    end
-
-    context 'with a float' do
-      it "parses unary op. with the right precedence" do
-        parsed("+1.23.hello").should == [:call, [:float, 1.23], :hello, [:arglist]]
-      end
-
-      it "parses unary op. as a method call" do
-        parsed("-1.23").should == [:float, -1.23]
-      end
-    end
-  end
-end

data/spec/lib/parser/undef_spec.rb

@@ -1,19 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The undef keyword" do
-  it "returns s(:undef) with the argument as an s(:lit)" do
-    parsed("undef a").should == [:undef, [:sym, :a]]
-  end
-
-  it "appends multiple parts onto end of list" do
-    parsed("undef a, b").should == [:undef, [:sym, :a], [:sym, :b]]
-  end
-
-  it "can take symbols or fitems" do
-    parsed("undef :foo").should == [:undef, [:sym, :foo]]
-  end
-
-  it "can take multiple symbols" do
-    parsed("undef :a, :b").should == [:undef, [:sym, :a], [:sym, :b]]
-  end
-end

data/spec/lib/parser/unless_spec.rb

@@ -1,13 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The unless keyword" do
-  it "returns s(:if) with reversed true and false bodies" do
-    parsed("unless 10; 20; end").should == [:if, [:int, 10], nil, [:int, 20]]
-    parsed("unless 10; 20; 30; end").should == [:if, [:int, 10], nil, [:block, [:int, 20], [:int, 30]]]
-    parsed("unless 10; 20; else; 30; end").should == [:if, [:int, 10], [:int, 30], [:int, 20]]
-  end
-
-  it "returns s(:if) with reversed true and false bodies for prefix unless" do
-    parsed("20 unless 10").should == [:if, [:int, 10], nil, [:int, 20]]
-  end
-end

data/spec/lib/parser/variables_spec.rb

@@ -1,116 +0,0 @@
-# encoding: utf-8
-
-require 'support/parser_helpers'
-
-describe Opal::Parser do
-  it "parses instance variables" do
-    parsed("@a").should == [:ivar, :@a]
-    parsed("@A").should == [:ivar, :@A]
-    parsed("@class").should == [:ivar, :@class]
-  end
-
-  it "parses instance variable assignment" do
-    parsed("@a = 1").should == [:iasgn, :@a, [:int, 1]]
-    parsed("@A = 1").should == [:iasgn, :@A, [:int, 1]]
-    parsed("@class = 1").should == [:iasgn, :@class, [:int, 1]]
-  end
-
-  describe "parses local variables" do
-    it "should be created when an identifier is previously assigned to" do
-      parsed("a = 1; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a]]
-      parsed("a = 1; a; a").should == [:block, [:lasgn, :a, [:int, 1]], [:lvar, :a], [:lvar, :a]]
-    end
-
-    it "should not be created when no lasgn is previously used on name" do
-      parsed("a").should == [:call, nil, :a, [:arglist]]
-      parsed("a = 1; b").should == [:block, [:lasgn, :a, [:int, 1]], [:call, nil, :b, [:arglist]]]
-    end
-  end
-
-  describe "parses local variables inside a def" do
-    it "should created by a norm arg" do
-      parsed("def a(b); b; end").should == [:def, nil, :a, [:args, [:arg, :b]], [:block, [:lvar, :b]]]
-      parsed("def a(b, c); c; end").should == [:def, nil, :a, [:args, [:arg, :b], [:arg, :c]], [:block, [:lvar, :c]]]
-    end
-
-    it "should be created by an opt arg" do
-      parsed("def a(b=10); b; end").should == [:def, nil, :a, [:args, [:optarg, :b, [:int, 10]]], [:block, [:lvar, :b]]]
-    end
-
-    it "should be created by a rest arg" do
-      parsed("def a(*b); b; end").should == [:def, nil, :a, [:args, [:restarg, :b]], [:block, [:lvar, :b]]]
-    end
-
-    it "should be created by a block arg" do
-      parsed("def a(&b); b; end").should == [:def, nil, :a, [:args, [:blockarg, :b]], [:block, [:lvar, :b]]]
-    end
-
-    it "should not be created from locals outside the def" do
-      parsed("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:int, 10]], [:def, nil, :b, [:args], [:block, [:call, nil, :a, [:arglist]]]]]
-    end
-  end
-
-  it "parses local var assignment" do
-    parsed("a = 1").should == [:lasgn, :a, [:int, 1]]
-    parsed("a = 1; b = 2").should == [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]
-  end
-
-  it "parses class variables" do
-    parsed("@@foo").should == [:cvar, :@@foo]
-  end
-
-  it "parses class variable assignment" do
-    parsed("@@foo = 100").should == [:cvdecl, :@@foo, [:int, 100]]
-  end
-
-  it "parses global variables" do
-    parsed("$foo").should == [:gvar, :$foo]
-    parsed("$:").should == [:gvar, :$:]
-  end
-
-  it "parses bulitin $-? gvars" do
-    parsed("$-0").should == [:gvar, :$-0]
-    parsed("$-a").should == [:gvar, :$-a]
-    parsed("$-A").should == [:gvar, :$-A]
-  end
-
-  it "parses global var assignment" do
-    parsed("$foo = 1").should == [:gasgn, :$foo, [:int, 1]]
-    parsed("$: = 1").should == [:gasgn, :$:, [:int, 1]]
-  end
-
-  it "parses as s(:nth_ref)" do
-    parsed('$1').first.should == :nth_ref
-  end
-
-  it "references the number 1..9 as first part" do
-    parsed('$1').should == [:nth_ref, '1']
-    parsed('$9').should == [:nth_ref, '9']
-  end
-
-  it "parses constants" do
-    parsed("FOO").should == [:const, :FOO]
-    parsed("BAR").should == [:const, :BAR]
-  end
-
-  it "parses constant assignment" do
-    parsed("FOO = 1").should == [:cdecl, :FOO, [:int, 1]]
-    parsed("FOO = BAR").should == [:cdecl, :FOO, [:const, :BAR]]
-  end
-
-  describe 'parsing unicode' do
-    if RUBY_ENGINE == 'jruby'
-      before { pending 'Until https://github.com/jruby/jruby/issues/3719 is fixed' }
-    end
-
-    it "works for constants" do
-      parsed("FOOλ = 1").should == [:cdecl, :FOOλ, [:int, 1]]
-    end
-
-    it "works for local variables" do
-      parsed("λ = 1").should == [:lasgn, :λ, [:int, 1]]
-      parsed("fooλ = 1").should == [:lasgn, :fooλ, [:int, 1]]
-      parsed("λfoo = 1").should == [:lasgn, :λfoo, [:int, 1]]
-    end
-  end
-end

data/spec/lib/parser/while_spec.rb

@@ -1,15 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The while keyword" do
-  it "returns an s(:while) with the given expr, body and true for head" do
-    parsed("while 1; 2; end").should == [:while, [:int, 1], [:int, 2]]
-  end
-
-  it "uses an s(:block) if body has more than one statement" do
-    parsed("while 1; 2; 3; end").should == [:while, [:int, 1], [:block, [:int, 2], [:int, 3]]]
-  end
-
-  it "treats the prefix while statement just like a regular while statement" do
-    parsed("1 while 2").should == [:while, [:int, 2], [:int, 1]]
-  end
-end

data/spec/lib/parser/yield_spec.rb

@@ -1,20 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The yield keyword" do
-  it "should return s(:yield) when no arguments given" do
-    parsed("yield").should == [:yield]
-  end
-
-  it "appends arguments onto end of s(:yield) without an arglist" do
-    parsed("yield 1").should == [:yield, [:int, 1]]
-    parsed("yield 1, 2").should == [:yield, [:int, 1], [:int, 2]]
-    parsed("yield 1, *2").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
-  end
-
-  it "accepts parans for any number of arguments" do
-    parsed("yield()").should == [:yield]
-    parsed("yield(1)").should == [:yield, [:int, 1]]
-    parsed("yield(1, 2)").should == [:yield, [:int, 1], [:int, 2]]
-    parsed("yield(1, *2)").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
-  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
-    path_finder.stub(:find) {|path| nil}
-    path_finder.stub(:find).with(path).and_return(full_path)
-    path_finder.stub(: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/shared/path_finder_shared.rb

@@ -1,19 +0,0 @@
-require 'lib/spec_helper'
-
-shared_examples :path_finder do
-  # @param path
-  # the path we want to read
-  #
-  # @param full_path
-  # the expanded path that should be found
-  #
-  it 'returns the full path if the path exists' do
-    expect(path_finder.find(path)).to eq(full_path)
-  end
-
-  it 'returns nil if the path is missing' do
-    expect(path_finder.find('unexpected-path')).to eq(nil)
-  end
-end
-
-

data/spec/lib/shared/path_reader_shared.rb

@@ -1,31 +0,0 @@
-require 'lib/spec_helper'
-
-# Below the helpers expected from a spec that
-# includes these shared examples:
-#
-# @object [PathReader] path_reader the object under test
-# @method [String]     path        the path we want to read
-# @method [String]     contents    the contents we expect to be read
-#
-shared_examples :path_reader do
-  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 'responds to #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
-end

data/spec/lib/spec_helper.rb

@@ -1,16 +0,0 @@
-if ENV['CHECK_COVERAGE']
-  require 'coveralls'
-  Coveralls.wear!
-end
-
-require 'opal'
-
-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 }
-end