opal 0.10.0 → 0.11.0

data/spec/lib/parser/lambda_spec.rb

@@ -1,219 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Lambda literals" do
-  it "should parse with either do/end construct or curly braces" do
-    parsed("-> {}").first.should == :call
-    parsed("-> do; end").first.should == :call
-  end
-
-  it "should parse as a call to 'lambda' with the lambda body as a block" do
-    parsed("-> {}").should == [:call, nil, :lambda, [:arglist], [:iter, nil]]
-  end
-
-  def parsed_args(source)
-    parsed(source)[4][1][1]
-  end
-
-  describe "with no args" do
-    it "should accept no args" do
-      parsed("-> {}")[4][1].should == nil
-    end
-  end
-
-  describe "with normal args" do
-    it "adds a single s(:masgn) for 1 norm arg" do
-      parsed("->(a) {}")[4][1].should == [:masgn, [:args, [:arg, :a]]]
-    end
-
-    it "lists multiple norm args inside a s(:masgn)" do
-      parsed("-> (a, b) {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b]]]
-      parsed("-> (a, b, c) {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b], [:arg, :c]]]
-    end
-  end
-
-  describe "with optional braces" do
-    it "parses normal args" do
-      parsed("-> a {}")[4][1].should == [:masgn, [:args, [:arg, :a]]]
-      parsed("-> a, b {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:arg, :b]]]
-    end
-
-    it "parses splat args" do
-      parsed("-> *a {}")[4][1].should == [:masgn, [:args, [:restarg, :a]]]
-      parsed("-> a, *b {}")[4][1].should == [:masgn, [:args, [:arg, :a], [:restarg, :b]]]
-    end
-
-    it "parses opt args" do
-      parsed("-> a = 1 {}")[4][1].should == [:masgn, [:args, [:optarg, :a, [:int, 1]]]]
-      parsed("-> a = 1, b = 2 {}")[4][1].should == [:masgn, [:args, [:optarg, :a, [:int, 1]], [:optarg, :b, [:int, 2]]]]
-    end
-
-    it "parses block args" do
-      parsed("-> &a {}")[4][1].should == [:masgn, [:args, [:block_pass, [:lasgn, :a]]]]
-    end
-  end
-
-  describe "with body statements" do
-    it "should be nil when no statements given" do
-      parsed("-> {}")[4][2].should == nil
-    end
-
-    it "should be the single sexp when given one statement" do
-      parsed("-> { 42 }")[4][2].should == [:int, 42]
-    end
-
-    it "should wrap multiple statements into a s(:block)" do
-      parsed("-> { 42; 3.142 }")[4][2].should == [:block, [:int, 42], [:float, 3.142]]
-    end
-  end
-
-  it "can parse do..end blocks inside lambda body" do
-    # regression test; see GH issue 544
-    call_b   = [:call, nil, :b, [:arglist], [:iter, [:masgn, [:args, [:arg, :c]]]]]
-    lambda   = [:call, nil, :lambda, [:arglist], [:iter, nil, call_b]]
-    expected = [:call, nil, :a, [:arglist, lambda]]
-    parsed("a -> { b do |c| end }").should == expected
-  end
-
-  it "can parse do..end after lambda body" do
-    # regression test; see GH issue 1228
-    expected = [:call, nil, :a, [:arglist, [:call, nil, :lambda, [:arglist], [:iter, nil, [:call, nil, :b, [:arglist]]]]], [:iter, nil]]
-    parsed("a ->{b} do; end").should == expected
-  end
-
-  context "kwargs as arguments" do
-    def s_kwarg
-      [:kwarg, :kw]
-    end
-
-    def s_kwoptarg
-      [:kwoptarg, :kwopt, [:sym, :default]]
-    end
-
-    def s_kwrestarg
-      [:kwrestarg, :kwrest]
-    end
-
-    def s_block
-      [:block_pass, [:lasgn, :blk]]
-    end
-
-    it "parses kwarg" do
-      parsed_args("->(kw:){}").should == [:args, s_kwarg]
-    end
-
-    it "parses kwoptarg" do
-      parsed_args("->(kwopt: :default){}").should == [:args, s_kwoptarg]
-    end
-
-    it "parses kwrestarg" do
-      parsed_args("->(**kwrest){}").should == [:args, s_kwrestarg]
-    end
-
-    it "parses kwarg + kwoptarg" do
-      parsed_args("->(kw:,kwopt: :default){}").should == [:args, s_kwarg, s_kwoptarg]
-    end
-
-    it "parses kwarg + kwrestarg" do
-      parsed_args("->(kw:,**kwrest){}").should == [:args, s_kwarg, s_kwrestarg]
-    end
-
-    it "parses kwarg + kwoptarg + kwrestarg" do
-      parsed_args("->(kw:,kwopt: :default,**kwrest){}").should == [:args, s_kwarg, s_kwoptarg, s_kwrestarg]
-    end
-
-    it "parses block + kwarg" do
-      parsed_args("->(kw:,&blk){}").should == [:args, s_kwarg, s_block]
-    end
-
-    it "parses block + kwoptarg" do
-      parsed_args("->(kwopt: :default,&blk){}").should == [:args, s_kwoptarg, s_block]
-    end
-
-    it "parses block + kwrestarg" do
-      parsed_args("->(**kwrest,&blk){}").should == [:args, s_kwrestarg, s_block]
-    end
-  end
-
-  context 'rest args' do
-    it "parses ->(*a,b)" do
-      parsed_args("->(*a, b){}").should == [:args, [:restarg, :a], [:arg, :b]]
-    end
-
-    it "parses ->(a,b=1,*c,d,&blk)" do
-      expected = [:args, [:arg, :a], [:optarg, :b, [:int, 1]], [:restarg, :c], [:arg, :d], [:block_pass, [:lasgn, :blk]]]
-      parsed_args("->(a,b=1,*c,d,&blk){}").should == expected
-    end
-
-    it "parses ->(a,b=1,c,&blk)" do
-      expected = [:args, [:arg, :a], [:optarg, :b, [:int, 1]], [:arg, :c], [:block_pass, [:lasgn, :blk]]]
-      parsed_args("->(a,b=1,c,&blk){}").should == expected
-    end
-
-    it "parses ->(a,*b,c,&blk){}" do
-      expected = [:args, [:arg, :a], [:restarg, :b], [:arg, :c], [:block_pass, [:lasgn, :blk]]]
-      parsed_args("->(a,*b,c,&blk){}").should == expected
-    end
-
-    it "parses ->(a=1,*b,c,&blk){}" do
-      expected = [:args, [:optarg, :a, [:int, 1]], [:restarg, :b], [:arg, :c], [:block_pass, [:lasgn, :blk]]]
-      parsed_args("->(a=1,*b,c,&blk){}").should == expected
-    end
-
-    it "parses ->(a=1,b,&blk)" do
-      expected = [:args, [:optarg, :a, [:int, 1]], [:arg, :b], [:block_pass, [:lasgn, :blk]]]
-      parsed_args("->(a=1,b,&blk){}").should == expected
-    end
-  end
-
-  context 'shadow args' do
-    it "parses lambda{|a;b|}" do
-      parsed_args("lambda{|a;b|}").should == [:args, [:arg, :a], [:shadowarg, :b]]
-    end
-
-    it "parses lambda{|;a|}" do
-      parsed_args("lambda{|;a|}").should == [:args, [:shadowarg, :a]]
-    end
-  end
-
-  context 'mlhs args' do
-    it "parses ->((a)){}" do
-      parsed_args("->((a)){}").should == [:args, [:mlhs, [:arg, :a]]]
-    end
-
-    it "parses ->((a,*b)){}" do
-      parsed_args("->((a,*b)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg, :b]]]
-    end
-
-    it "parses ->((a,*b,c)){}" do
-      parsed_args("->((a,*b,c)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg, :b], [:arg, :c]]]
-    end
-
-    it "parses ->((a,*)){}" do
-      parsed_args("->((a,*)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg]]]
-    end
-
-    it "parses ->((a,*,b)){}" do
-      parsed_args("->((a,*,b)){}").should == [:args, [:mlhs, [:arg, :a], [:restarg], [:arg, :b]]]
-    end
-
-    it "parses ->((*a)){}" do
-      parsed_args("->((*a)){}").should == [:args, [:mlhs, [:restarg, :a]]]
-    end
-
-    it "parses ->((*a,b)){}" do
-      parsed_args("->((*a,b)){}").should == [:args, [:mlhs, [:restarg, :a], [:arg, :b]]]
-    end
-
-    it "parses ->((*)){}" do
-      parsed_args("->((*)){}").should == [:args, [:mlhs, [:restarg]]]
-    end
-
-    it "parses ->((*,a)){}" do
-      parsed_args("->((*,a)){}").should == [:args, [:mlhs, [:restarg], [:arg, :a]]]
-    end
-
-    it "parses ->(a,(b,(c,d))){}" do
-      parsed_args("->(a,(b,(c,d))){}").should == [:args, [:arg, :a], [:mlhs, [:arg, :b], [:mlhs, [:arg, :c], [:arg, :d]]]]
-    end
-  end
-end

data/spec/lib/parser/literal_spec.rb

@@ -1,118 +0,0 @@
-require 'support/parser_helpers'
-
-describe Opal::Parser do
-
-  it "parses true keyword" do
-    parsed("true").should == [:true]
-  end
-
-  it "true cannot be assigned to" do
-    lambda {
-      parsed "true = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses false keyword" do
-    parsed("false").should == [:false]
-  end
-
-  it "false cannot be assigned to" do
-    lambda {
-      parsed "true = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses nil keyword" do
-    parsed("nil").should == [:nil]
-  end
-
-  it "nil cannot be assigned to" do
-    lambda {
-      parsed "nil = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses self keyword" do
-    parsed("self").should == [:self]
-  end
-
-  it "self cannot be assigned to" do
-    lambda {
-      parsed "self = 1"
-    }.should raise_error(Exception)
-  end
-
-  it "parses __FILE__ and should always return a s(:str) with given parser filename" do
-    parsed("__FILE__", "foo").should == [:str, "foo"]
-  end
-
-  it "parses __LINE__ and should always return a literal number of the current line" do
-    parsed("__LINE__").should == [:int, 1]
-    parsed("\n__LINE__").should == [:int, 2]
-  end
-
-  it "parses integers as a s(:int) sexp" do
-    parsed("32").should == [:int, 32]
-  end
-
-  it "parses floats as a s(:float)" do
-    parsed("3.142").should == [:float, 3.142]
-  end
-
-  describe "parsing arrays" do
-    it "should parse empty arrays as s(:array)" do
-      parsed("[]").should == [:array]
-    end
-
-    it "should append regular args onto end of array sexp" do
-      parsed("[1]").should == [:array, [:int, 1]]
-      parsed("[1, 2]").should == [:array, [:int, 1], [:int, 2]]
-      parsed("[1, 2, 3]").should == [:array, [:int, 1], [:int, 2], [:int, 3]]
-    end
-
-    it "should return a single item s(:array) with given splat if no norm args" do
-      parsed("[*1]").should == [:array, [:splat, [:int, 1]]]
-    end
-
-    it "should allow splats combined with any number of norm args" do
-      parsed("[1, *2]").should == [:array, [:int, 1], [:splat, [:int, 2]]]
-      parsed("[1, 2, *3]").should == [:array, [:int, 1], [:int, 2], [:splat, [:int, 3]]]
-    end
-  end
-
-  describe "parsing hashes" do
-    it "without any assocs should return an empty hash sexp" do
-      parsed("{}").should == [:hash]
-    end
-
-    it "adds each assoc pair as individual args onto sexp" do
-      parsed("{1 => 2}").should == [:hash, [:int, 1], [:int, 2]]
-      parsed("{1 => 2, 3 => 4}").should == [:hash, [:int, 1], [:int, 2], [:int, 3], [:int, 4]]
-    end
-
-    it "supports 1.9 style hash keys" do
-      parsed("{ a: 1 }").should == [:hash, [:sym, :a], [:int, 1]]
-      parsed("{ a: 1, b: 2 }").should == [:hash, [:sym, :a], [:int, 1], [:sym, :b], [:int, 2]]
-    end
-
-    it "parses hash arrows without spaces around arguments" do
-      parsed("{1=>2}").should == [:hash, [:int, 1], [:int, 2]]
-      parsed("{:foo=>2}").should == [:hash, [:sym, :foo], [:int, 2]]
-    end
-  end
-
-  describe "parsing regexps" do
-    it "parses a regexp" do
-      parsed("/lol/").should == [:regexp, 'lol', nil]
-    end
-
-    it "parses regexp options" do
-      parsed("/lol/i").should == [:regexp, 'lol', 'i']
-    end
-
-    it "can parse regexps using %r notation" do
-      parsed('%r(foo)').should == [:regexp, 'foo', nil]
-      parsed('%r(foo)i').should == [:regexp, 'foo', 'i']
-    end
-  end
-end

data/spec/lib/parser/masgn_spec.rb

@@ -1,37 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Masgn" do
-  describe "with a single lhs splat" do
-    it "returns a s(:masgn)" do
-      parsed('*a = 1, 2').first.should == :masgn
-      parsed('* = 1, 2').first.should == :masgn
-    end
-
-    it "wraps splat inside a s(:array)" do
-      parsed('*a = 1, 2')[1].should == [:array, [:splat, [:lasgn, :a]]]
-      parsed('* = 1, 2')[1].should == [:array, [:splat]]
-    end
-  end
-
-  describe "with more than 1 lhs item" do
-    it "returns a s(:masgn) " do
-      parsed('a, b = 1, 2').first.should == :masgn
-    end
-
-    it "collects all lhs args into an s(:array)" do
-      parsed('a, b = 1, 2')[1].should == [:array, [:lasgn, :a], [:lasgn, :b]]
-      parsed('@a, @b = 1, 2')[1].should == [:array, [:iasgn, :@a], [:iasgn, :@b]]
-    end
-
-    it "supports splat parts" do
-      parsed('a, *b = 1, 2')[1].should == [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]
-      parsed('@a, * = 1, 2')[1].should == [:array, [:iasgn, :@a], [:splat]]
-    end
-  end
-
-  describe "with a single rhs argument" do
-    it "should wrap rhs in an s(:to_ary)" do
-      parsed('a, b = 1')[2].should == [:to_ary, [:int, 1]]
-    end
-  end
-end

data/spec/lib/parser/module_spec.rb

@@ -1,27 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The module keyword" do
-  it "returns an empty s(:block) when given an empty body" do
-    parsed('module A; end').should == [:module, [:const, :A], [:block]]
-  end
-
-  it "does not place single expressions into a s(:block)" do
-    parsed('module A; 1; end').should == [:module, [:const, :A], [:int, 1]]
-  end
-
-  it "adds multiple body expressions into a s(:block)" do
-    parsed('module A; 1; 2; end').should == [:module, [:const, :A], [:block, [:int, 1], [:int, 2]]]
-  end
-
-  it "should accept just a constant for the module name" do
-    parsed('module A; end')[1].should == [:const, :A]
-  end
-
-  it "should accept a prefix constant for the module name" do
-    parsed('module ::A; end')[1].should == [:colon3, :A]
-  end
-
-  it "should accepts a nested constant for the module name" do
-    parsed('module A::B; end')[1].should == [:colon2, [:const, :A], :B]
-  end
-end

data/spec/lib/parser/not_spec.rb

@@ -1,21 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The not keyword" do
-  it "returns a call sexp" do
-    parsed("not self").should == [:call, [:self], '!'.to_sym, [:arglist]]
-    parsed("not 42").should == [:call, [:int, 42], '!'.to_sym, [:arglist]]
-  end
-end
-
-describe "The '!' expression" do
-  it "returns a call sexp" do
-    parsed("!self").should == [:call, [:self], '!'.to_sym, [:arglist]]
-    parsed("!42").should == [:call, [:int, 42], '!'.to_sym, [:arglist]]
-  end
-end
-
-describe "The '!~' expression" do
-  it "does not rewrite as !(lhs =~ rhs)" do
-    parsed("1 !~ 2").should == [:call, [:int, 1], :!~, [:arglist, [:int, 2]]]
-  end
-end

data/spec/lib/parser/op_asgn1_spec.rb

@@ -1,23 +0,0 @@
-require 'support/parser_helpers'
-
-describe "op_asgn1" do
-  it "returns s(:op_asgn1)" do
-    parsed('self[:foo] += 1')[0].should == :op_asgn1
-  end
-
-  it "correctly assigns the receiver" do
-    parsed("self[:foo] += 1")[1].should == [:self]
-  end
-
-  it "returns an arglist for args inside braces" do
-    parsed("self[:foo] += 1")[2].should == [:arglist, [:sym, :foo]]
-  end
-
-  it "only uses the operator, not with '=' appended" do
-    parsed("self[:foo] += 1")[3].should == '+'
-  end
-
-  it "uses a simple sexp, not an arglist" do
-    parsed("self[:foo] += 1")[4].should == [:int, 1]
-  end
-end

data/spec/lib/parser/op_asgn2_spec.rb

@@ -1,23 +0,0 @@
-require 'support/parser_helpers'
-
-describe "op_asgn2" do
-  it "returns s(:op_asgn2)" do
-    parsed('self.foo += 1')[0].should == :op_asgn2
-  end
-
-  it "correctly assigns the receiver" do
-    parsed("self.foo += 1")[1].should == [:self]
-  end
-
-  it "appends '=' onto the identifier in the sexp" do
-    parsed("self.foo += 1")[2].should == :foo=
-  end
-
-  it "only uses the operator, not with '=' appended" do
-    parsed("self.foo += 1")[3].should == :+
-  end
-
-  it "uses a simple sexp, not an arglist" do
-    parsed("self.foo += 1")[4].should == [:int, 1]
-  end
-end

data/spec/lib/parser/op_asgn_spec.rb

@@ -1,17 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Operator assignment statements on local variables" do
-  it "parses |= with a lvar on the left and parenthesized expr on the right" do
-    # regression test; see GH issue 995
-    asgn = [:lasgn, :var, [:int, 1]]
-    opasgn = [:lasgn, :var, [:call, [:lvar, :var], :|, [:arglist, [:paren, [:int, 1]]]]]
-    parsed('var = 1; var |= (1)').should == [:block, asgn, opasgn]
-  end
-
-  it "parses >>= with a lvar on the left and parenthesized expr on the right" do
-    # regression test; see GH issue 995
-    asgn = [:lasgn, :var, [:int, 1]]
-    opasgn = [:lasgn, :var, [:call, [:lvar, :var], :>>, [:arglist, [:paren, [:int, 1]]]]]
-    parsed('var = 1; var >>= (1)').should == [:block, asgn, opasgn]
-  end
-end

data/spec/lib/parser/or_spec.rb

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

data/spec/lib/parser/return_spec.rb

@@ -1,22 +0,0 @@
-require 'support/parser_helpers'
-
-describe "The return keyword" do
-  it "should return s(:return) when given no arguments" do
-    parsed("return").should == [:return]
-  end
-
-  it "returns s(:return) with the direct argument when given one argument" do
-    parsed("return 1").should == [:return, [:int, 1]]
-    parsed("return *2").should == [:return, [:splat, [:int, 2]]]
-  end
-
-  it "returns s(:return) with an s(:array) when args size > 1" do
-    parsed("return 1, 2").should == [:return, [:array, [:int, 1], [:int, 2]]]
-    parsed("return 1, *2").should == [:return, [:array, [:int, 1], [:splat, [:int, 2]]]]
-  end
-
-  it "can handle a %{string literal with percent syntax}" do
-    # regression test; see GH issue 1089
-    parsed("return %{a}").should == [:return, [:str, "a"]]
-  end
-end

data/spec/lib/parser/sclass_spec.rb

@@ -1,21 +0,0 @@
-require 'support/parser_helpers'
-
-describe "Singleton classes" do
-  it "returns an empty s(:block) when given an empty body" do
-    parsed('class << A; end')[2].should == [:block]
-  end
-
-  it "does not place single expressions into an s(:block)" do
-    parsed('class << A; 1; end')[2].should == [:int, 1]
-  end
-
-  it "adds multiple body expressions into a s(:block)" do
-    parsed('class << A; 1; 2; end')[2].should == [:block, [:int, 1], [:int, 2]]
-  end
-
-  it "should accept any expressions for singleton part" do
-    parsed('class << A; end').should == [:sclass, [:const, :A], [:block]]
-    parsed('class << self; end').should == [:sclass, [:self], [:block]]
-  end
-end
-