opal 0.10.6 → 0.11.0.rc1

data/spec/lib/lexer_spec.rb

@@ -1,110 +0,0 @@
-require 'support/parser_helpers'
-require 'opal/parser'
-
-describe Opal::Lexer do
-  it "sets correct line information for each token" do
-    expect_lines("42").to eq([1])
-    expect_lines("\n3.142").to eq([2])
-    expect_lines("3.142\n42\n57").to eq([1, 2, 3])
-  end
-
-  it "increments the line count over multiple new lines" do
-    expect_lines("1\n\n\n2").to eq([1, 4])
-    expect_lines("\n\n\n3\n\n5\n\n").to eq([4, 6])
-  end
-
-  it "increments line numbers over =begin...=end blocks" do
-    expect_lines("=begin\n=end\n1").to eq([3])
-    expect_lines("=begin\nfoo\nbar\n=end\n42\n43").to eq([5, 6])
-  end
-
-  it "sets correct column for each token" do
-    expect_columns("1").to eq([0])
-    expect_columns("1;2; 3").to eq([0, 2, 5])
-    expect_columns("    \t3").to eq([5])
-  end
-
-  it "sets the column to 0 on each new line" do
-    expect_columns("1\n2\n\n\n3\n 4").to eq([0, 0, 0, 1])
-  end
-
-  it "sets column with regard to whitespace and other tokens before it" do
-    expect_columns("true;  false;  self\n  ni;").to eq([0, 7, 15, 2])
-  end
-
-  describe "double-quoted strings" do
-    it "escape backslashes in strings" do
-      expect_parsed_string("\"foo\"").to eq("foo")
-      expect_parsed_string("\"foo\\tbar\"").to eq("foo\tbar")
-      expect_parsed_string("\"\\\"foo\"").to eq("\"foo")
-    end
-
-    it "removes new line in string directly after backslash" do
-      expect_parsed_string("\"foo\\\nbar\"").to eq("foobar")
-    end
-  end
-
-  describe "single-quoted strings" do
-    it "do not support interpolation" do
-      expect_parsed_string("'foo\#{self}'").to eq('foo#{self}')
-      expect_parsed_string("'\#@bar'").to eq('#@bar')
-      expect_parsed_string("'\#$baz'").to eq('#$baz')
-    end
-
-    it "do not escape backslashed characters" do
-      expect_parsed_string("'foo'").to eq("foo")
-      expect_parsed_string("'foo\\tbar'").to eq("foo\\tbar")
-    end
-
-    it "can escape \\ and \' characters" do
-      expect_parsed_string("'a\\\\b\\'c'").to eq("a\\b'c")
-    end
-  end
-
-  describe "escaped characters" do
-    it "can parse octal escape sequences" do
-      expect_parsed_string('"\\101\\103\\102"').to eq("ACB")
-    end
-
-    it "can parse hex escape sequences" do
-      expect_parsed_string('"\\x61\\x63\\x62"').to eq('acb')
-    end
-
-    if defined?(::Encoding)
-      it "can parse simple unicode sequences" do
-        expect_parsed_string('"\\u1234"').to eq("\u1234")
-      end
-    end
-  end
-
-  describe "__END__ content in a source file" do
-    it "ignores token and following content if at start of line and followed by newline" do
-      expect_parsed("42\n__END__").to eq([:int, 42])
-      expect_parsed("42\n__END__\nFred").to eq([:int, 42])
-      expect_parsed(" __END__").to eq([:call, nil, :__END__, [:arglist]])
-      expect_parsed("__END__ ").to eq([:call, nil, :__END__, [:arglist]])
-      expect_parsed("__END__ 42").to eq([:call, nil, :__END__, [:arglist, [:int, 42]]])
-    end
-
-    it "adds any __END__ content to lexer.eof_content" do
-      parser = Opal::Parser.new
-      parser.parse("42")
-      expect(parser.lexer.eof_content).to eq(nil)
-
-      parser = Opal::Parser.new
-      parser.parse("42\n__END__\nFord\nPerfect")
-      expect(parser.lexer.eof_content).to eq("Ford\nPerfect")
-
-      parser = Opal::Parser.new
-      parser.parse("42\n__END__\n")
-      expect(parser.lexer.eof_content).to eq("")
-    end
-  end
-
-  describe "variable dereferencing ([])" do
-    it "handles referencing correctly on local variables in scope" do
-      expect_parsed("x = 0; x [0]").to eq([:block, [:lasgn, :x, [:int, 0]],
-       [:call, [:lvar, :x], :[], [:arglist, [:int, 0]]]])
-    end
-  end
-end

data/spec/lib/parser/alias_spec.rb

@@ -1,26 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The alias keyword" do
-  describe "with fitem" do
-    it "should return an s(:alias) with s(:sym)" do
-      parsed("alias a b").should == [:alias, [:sym, :a], [:sym, :b]]
-      parsed("alias == equals").should == [:alias, [:sym, :==], [:sym, :equals]]
-    end
-
-    it "should accept symbols as names" do
-      parsed("alias :foo :bar").should == [:alias, [:sym, :foo], [:sym, :bar]]
-    end
-  end
-
-  describe "with gvar" do
-    it "should return a s(:valias) with two gvars as arguments" do
-      parsed("alias $foo $bar").should == [:valias, :$foo, :$bar]
-    end
-  end
-
-  describe "with gvar and nth ref" do
-    it "should return a s(:valias) with two values as arguments" do
-      parsed("alias $foo $1").should == [:valias, :$foo, :"1"]
-    end
-  end
-end

data/spec/lib/parser/and_spec.rb

@@ -1,13 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The and statement" do
-  it "should always return s(:and)" do
-    parsed("1 and 2").should == [:and, [:int, 1], [:int, 2]]
-  end
-end
-
-describe "The && expression" do
-  it "should always return s(:and)" do
-    parsed("1 && 2").should == [:and, [:int, 1], [:int, 2]]
-  end
-end

data/spec/lib/parser/aref_spec.rb

@@ -1,10 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Method calls using receiver[] syntax" do
-  it "accepts trailing &block argument" do
-    # regression test; see GH issue #959
-    splat = [:splat, [:call, nil, :args, [:arglist]]]
-    block = [:block_pass, [:call, nil, :block, [:arglist]]]
-    parsed("User[*args, &block]").should == [:call, [:const, :User], :[], [:arglist, splat, block]]
-  end
-end

data/spec/lib/parser/attrasgn_spec.rb

@@ -1,28 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Attribute assignments" do
-  it "should return a s(:attrasgn) for simple assignments" do
-    parsed('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
-    parsed('bar.foo = 1').should == [:attrasgn, [:call, nil, :bar, [:arglist]], :foo=, [:arglist, [:int, 1]]]
-    parsed('@bar.foo = 1').should == [:attrasgn, [:ivar, :@bar], :foo=, [:arglist, [:int, 1]]]
-  end
-
-  it "accepts both '.' and '::' for method call operators" do
-    parsed('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
-    parsed('self::foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
-  end
-
-  it "can accept a constant as assignable name when using '.'" do
-    parsed('self.FOO = 1').should == [:attrasgn, [:self], :FOO=, [:arglist, [:int, 1]]]
-  end
-
-  describe "when setting element reference" do
-    it "uses []= as the method call" do
-      parsed('self[1] = 2').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2]]]
-    end
-
-    it "supports multiple arguments inside brackets" do
-      parsed('self[1, 2] = 3').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2], [:int, 3]]]
-    end
-  end
-end

data/spec/lib/parser/begin_spec.rb

@@ -1,42 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The begin keyword" do
-  it "should be removed when used without a resuce or enusre body" do
-    parsed('begin; 1; end').should == [:int, 1]
-    parsed('begin; 1; 2; end').should == [:block, [:int, 1], [:int, 2]]
-  end
-
-  describe "with 'rescue' bodies" do
-    it "should create a s(:rescue) sexp" do
-      parsed('begin; 1; rescue; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
-    end
-
-    it "allows multiple rescue bodies" do
-      parsed('begin 1; rescue; 2; rescue; 3; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]], [:resbody, [:array], [:int, 3]]]
-    end
-
-    it "accepts a list of classes used to match against the exception" do
-      parsed('begin 1; rescue Klass; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass]], [:int, 2]]]
-    end
-
-    it "accepts an identifier to assign exception to" do
-      parsed('begin 1; rescue => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
-      parsed('begin 1; rescue Klass => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
-    end
-
-    it "accepts an ivar to assign exception to" do
-      parsed('begin 1; rescue => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
-      parsed('begin 1; rescue Klass => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
-    end
-
-    it "should parse newline right after rescue" do
-      parsed("begin; 1; rescue\n 2; end").should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
-    end
-  end
-
-  describe "with an 'ensure' block" do
-    it "should propagate into single s(:ensure) statement when no rescue block given" do
-      parsed('begin; 1; ensure; 2; end').should == [:ensure, [:int, 1], [:int, 2]]
-    end
-  end
-end

data/spec/lib/parser/block_spec.rb

@@ -1,12 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Block statements" do
-  it "should return the direct expression if only one expresssion in block" do
-    parsed("42").should == [:int, 42]
-  end
-
-  it "should return an s(:block) with all expressions appended for > 1 expression" do
-    parsed("42; 43").should == [:block, [:int, 42], [:int, 43]]
-    parsed("42; 43\n44").should == [:block, [:int, 42], [:int, 43], [:int, 44]]
-  end
-end

data/spec/lib/parser/break_spec.rb

@@ -1,17 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The break keyword" do
-  it "should return s(:break) when given no args" do
-    parsed("break").should == [:break]
-  end
-
-  it "returns s(:break) with a single arg not wrapped in s(:array)" do
-    parsed("break 1").should == [:break, [:int, 1]]
-    parsed("break *1").should == [:break, [:splat, [:int, 1]]]
-  end
-
-  it "returns s(:break) with an s(:array) for args size > 1" do
-    parsed("break 1, 2").should == [:break, [:array, [:int, 1], [:int, 2]]]
-    parsed("break 1, *2").should == [:break, [:array, [:int, 1], [:splat, [:int, 2]]]]
-  end
-end

data/spec/lib/parser/call_spec.rb

@@ -1,201 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Method calls" do
-  it "should use 'nil' for calls without a receiver" do
-    parsed("foo").should == [:call, nil, :foo, [:arglist]]
-    parsed("foo()").should == [:call, nil, :foo, [:arglist]]
-  end
-
-  it "should always have an arglist when not passed any arguments" do
-    parsed("foo").should == [:call, nil, :foo, [:arglist]]
-    parsed("self.foo").should == [:call, [:self], :foo, [:arglist]]
-    parsed("foo()").should == [:call, nil, :foo, [:arglist]]
-    parsed("self.foo()").should == [:call, [:self], :foo, [:arglist]]
-  end
-
-  it "appends all arguments onto arglist" do
-    parsed("foo 1").should == [:call, nil, :foo, [:arglist, [:int, 1]]]
-    parsed("foo 1, 2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:int, 2]]]
-    parsed("foo 1, *2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
-  end
-
-  it "supports leading dots on newline" do
-    parsed("foo\n.bar").should == [:call, [:call, nil, :foo, [:arglist]], :bar, [:arglist]]
-    lambda { parsed("foo\n..bar") }.should raise_error(Exception)
-  end
-
-  it "parses method starting on the next line after \\" do
-    parsed("\\\nfoo").should == [:call, nil, :foo, [:arglist]]
-  end
-end
-
-describe "Operator calls" do
-  it "should parse all other operators into method calls" do
-    parsed("1 % 2").should == [:call, [:int, 1], :%, [:arglist, [:int, 2]]]
-    parsed("1 ** 2").should == [:call, [:int, 1], :**, [:arglist, [:int, 2]]]
-
-    parsed("+self").should == [:call, [:self], :+@, [:arglist]]
-    parsed("-self").should == [:call, [:self], :-@, [:arglist]]
-
-    parsed("1 | 2").should == [:call, [:int, 1], :|, [:arglist, [:int, 2]]]
-    parsed("1 ^ 2").should == [:call, [:int, 1], :^, [:arglist, [:int, 2]]]
-    parsed("1 & 2").should == [:call, [:int, 1], :&, [:arglist, [:int, 2]]]
-    parsed("1 <=> 2").should == [:call, [:int, 1], :<=>, [:arglist, [:int, 2]]]
-
-    parsed("1 < 2").should == [:call, [:int, 1], :<, [:arglist, [:int, 2]]]
-    parsed("1 <= 2").should == [:call, [:int, 1], :<=, [:arglist, [:int, 2]]]
-    parsed("1 > 2").should == [:call, [:int, 1], :>, [:arglist, [:int, 2]]]
-    parsed("1 >= 2").should == [:call, [:int, 1], :>=, [:arglist, [:int, 2]]]
-
-    parsed("1 == 2").should == [:call, [:int, 1], :==, [:arglist, [:int, 2]]]
-    parsed("1 === 2").should == [:call, [:int, 1], :===, [:arglist, [:int, 2]]]
-    parsed("1 =~ 2").should == [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]
-
-    parsed("~1").should == [:call, [:int, 1], :~, [:arglist]]
-    parsed("1 << 2").should == [:call, [:int, 1], :<<, [:arglist, [:int, 2]]]
-    parsed("1 >> 2").should == [:call, [:int, 1], :>>, [:arglist, [:int, 2]]]
-  end
-
-  it "optimizes +@ and -@ on numerics" do
-    parsed("+1").should == [:int, 1]
-    parsed("-1").should == [:int, -1]
-  end
-end
-
-describe "Optional paren calls" do
-  it "should correctly parse - and -@" do
-    parsed("x - 1").should == [:call, [:call, nil, :x, [:arglist]], :-, [:arglist, [:int, 1]]]
-    parsed("x -1").should == [:call, nil, :x, [:arglist, [:int, -1]]]
-  end
-
-  it "should correctly parse + and +@" do
-    parsed("x + 1").should == [:call, [:call, nil, :x, [:arglist]], :+, [:arglist, [:int, 1]]]
-    parsed("x +1").should == [:call, nil, :x, [:arglist, [:int, 1]]]
-  end
-
-  it "should correctly parse / and regexps" do
-    parsed("x / 500").should == [:call, [:call, nil, :x, [:arglist]], :/, [:arglist, [:int, 500]]]
-    parsed("x /foo/").should == [:call, nil, :x, [:arglist, [:regexp, 'foo', nil]]]
-  end
-
-  it "should parse LPAREN_ARG correctly" do
-    parsed("x (1).y").should == [:call, nil, :x, [:arglist, [:call, [:int, 1], :y, [:arglist]]]]
-    parsed("x(1).y").should == [:call, [:call, nil, :x, [:arglist, [:int, 1]]], :y, [:arglist]]
-  end
-end
-
-describe "Operator precedence" do
-  it "should be raised with parentheses" do
-   parsed("(1 + 2) + (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :+,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-   parsed("(1 + 2) - (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :-,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-   parsed("(1 + 2) * (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :*,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-   parsed("(1 + 2) / (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :/,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-  end
-end
-
-describe "Calls with keywords as method names" do
-
-  keywords = %w[class module defined? def undef end do if unless else elsif self true false
-                nil __LINE__ __FILE__ begin rescue ensure case when or and not return next
-                redo break super then while until yield alias]
-
-  it "should correctly parse the keyword as a method name when after a '.'" do
-    keywords.each do |kw|
-      parsed("self.#{kw}").should == [:call, [:self], kw.to_sym, [:arglist]]
-    end
-  end
-end
-
-describe "Calls with operators as method names" do
-  operators = %w[+ - * / & ** | ^ & <=> > >= < <= << >>]
-
-  it "should correctly parse the operator as method name after '.'" do
-    operators.each do |op|
-      parsed("self.#{op}").should == [:call, [:self], op.to_sym, [:arglist]]
-      parsed("self.#{op}(1)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1]]]
-      parsed("self.#{op}(1, 2)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1], [:int, 2]]]
-    end
-  end
-end
-
-describe "Command calls with operators" do
-  it "parses operators before \n in command calls" do
-    [:<<, :>>, :|, :^, :&, :<=>, :==, :===, :=~, :>, :>=, :<, :<=, :<<, :>>, :%, :**].each do |mid|
-      parsed("self #{mid}\nself").should == [:call, [:self], mid, [:arglist, [:self]]]
-    end
-  end
-end
-
-describe "Command calls without a space" do
-  it "correctly parses symbol arguments" do
-    parsed("self.inject:+").should == [:call, [:self], :inject,
-                                       [:arglist, [:sym, :+]]]
-  end
-end
-
-describe 'Operator calls followed by parens' do
-  it 'correctly parses parens' do
-    parsed('1/(2)').should == [:call, [:int, 1], '/'.to_sym, [:arglist, [:paren, [:int, 2]]]]
-    parsed('1*(2)').should == [:call, [:int, 1], '*'.to_sym, [:arglist, [:paren, [:int, 2]]]]
-    parsed('1+(2)').should == [:call, [:int, 1], '+'.to_sym, [:arglist, [:paren, [:int, 2]]]]
-    parsed('1-(2)').should == [:call, [:int, 1], '-'.to_sym, [:arglist, [:paren, [:int, 2]]]]
-  end
-end
-
-describe 'Calls that include a hash' do
-  it 'parses correctly when a hash followed by a block' do
-    parsed('foo(a => 2, &block)').should == [:call, nil, :foo, [:arglist, [:hash, [:call, nil, :a, [:arglist]], [:int, 2]],[:block_pass, [:call, nil, :block, [:arglist]]]]]
-  end
-  
-  it 'parses correctly when only a hash is passed' do
-    parsed('foo(a => 2)').should == [:call, nil, :foo, [:arglist, [:hash, [:call, nil, :a, [:arglist]], [:int, 2]]]]
-  end
-  
-  it 'parses correctly when ending in hash' do
-    parsed('foo(1, a => 2)').should == [:call, nil, :foo, [:arglist, [:int, 1], [:hash, [:call, nil, :a, [:arglist]], [:int, 2]]]]
-  end
-  
-  it 'parses correctly with another parameter and hash followed by a block' do
-    parsed('foo(1, a => 2, &block)').should == [:call, nil, :foo, [:arglist, [:int, 1], [:hash, [:call, nil, :a, [:arglist]], [:int, 2]], [:block_pass, [:call, nil, :block, [:arglist]]]]]
-  end
-end
-
-describe 'Calls with trailing comma' do
-  it 'parses correctly' do
-    parsed('foo(1,)').should == [:call, nil, :foo, [:arglist, [:int, 1]]]
-    parsed('foo(1, 2,)').should == [:call, nil, :foo, [:arglist, [:int, 1], [:int, 2]]]
-
-    parsed('foo(a: 100,)').should == [:call, nil, :foo, [:arglist,
-      [:hash, [:sym, :a], [:int, 100]]]]
-  end
-end
-
-describe 'Calls with kwsplat' do
-  it 'parses empty kwsplat' do
-    parsed('foo(**{})').should == [:call, nil, :foo, [:arglist, [:hash, [:kwsplat, [:hash]]]]]
-  end
-
-  it 'parses non-empty kwsplat' do
-    parsed('foo(**{ a: 1 })').should == [:call, nil, :foo, [:arglist, [:hash, [:kwsplat, [:hash, [:sym, :a], [:int, 1]]]]]]
-  end
-
-  it 'supports kwargs and kwsplat' do
-    parsed('foo(a: 1, **{ b: 2 })').should == [:call, nil, :foo, [:arglist, [:hash, [:sym, :a], [:int, 1], [:kwsplat, [:hash, [:sym, :b], [:int, 2]]]]]]
-  end
-end