opal 0.5.5 → 0.6.0

data/spec/cli/parser/comments_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Multiline comments" do
+  it "parses multiline comments and ignores them" do
+    parsed("=begin\nfoo\n=end\n100").should == [:int, 100]
+  end
+
+  it "raises an exception if not closed before end of file" do
+    lambda { parsed("=begin\nfoo\nbar") }.should raise_error(Exception, /embedded document meets end of file/)
+  end
+end

data/spec/cli/parser/def_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The def keyword" do
+  describe "for normal definitions" do
+    it "should return s(:def)" do
+      parsed("def a; end").should == [:def, nil, :a, [:args], [:block, [:nil]]]
+    end
+
+    it "adds s(:nil) on an empty body" do
+      parsed("def foo; end").last.should == [:block, [:nil]]
+    end
+  end
+
+  describe "for singleton definitions" do
+    it "should return s(:def)" do
+      parsed("def self.a; end").should == [:def, [:self], :a, [:args], [:block, [:nil]]]
+    end
+
+    it "adds s(:nil) on an empty body" do
+      parsed("def self.foo; end").last.should == [:block, [:nil]]
+    end
+  end
+
+  describe "with normal args" do
+    it "should list all args" do
+      parsed("def foo(a); end")[3].should == [:args, :a]
+      parsed("def foo(a, b); end")[3].should == [:args, :a, :b]
+      parsed("def foo(a, b, c); end")[3].should == [:args, :a, :b, :c]
+    end
+  end
+
+  describe "with opt args" do
+    it "should list all opt args as well as block with each lasgn" do
+      parsed("def foo(a = 1); end")[3].should == [:args, :a, [:block, [:lasgn, :a, [:int, 1]]]]
+      parsed("def foo(a = 1, b = 2); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]
+    end
+
+    it "should list lasgn block after all other args" do
+      parsed("def foo(a, b = 1); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :b, [:int, 1]]]]
+      parsed("def foo(b = 1, *c); end")[3].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:int, 1]]]]
+      parsed("def foo(b = 1, &block); end")[3].should == [:args, :b, :"&block", [:block, [:lasgn, :b, [:int, 1]]]]
+    end
+  end
+
+  describe "with rest args" do
+    it "should list rest args in place as a symbol with '*' prefix" do
+      parsed("def foo(*a); end")[3].should == [:args, :"*a"]
+    end
+
+    it "uses '*' as an arg name for rest args without a name" do
+      parsed("def foo(*); end")[3].should == [:args, :"*"]
+    end
+  end
+
+  describe "with block arg" do
+    it "should list block argument with the '&' prefix" do
+      parsed("def foo(&a); end")[3].should == [:args, :"&a"]
+    end
+  end
+end
+

data/spec/cli/parser/if_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The if keyword" do
+  it "should return an s(:if) with given truthy and falsy bodies" do
+    parsed("if 1; 2; else; 3; end").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
+  end
+
+  it "uses nil as fasly body if not given else-then" do
+    parsed("if 1; 2; end").should == [:if, [:int, 1], [:int, 2], nil]
+  end
+
+  it "is treats elsif parts as sub if expressions for else body" do
+    parsed("if 1; 2; elsif 3; 4; else; 5; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], [:int, 5]]]
+    parsed("if 1; 2; elsif 3; 4; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], nil]]
+  end
+
+  it "returns a simple s(:if) with nil else body for prefix if statement" do
+    parsed("1 if 2").should == [:if, [:int, 2], [:int, 1], nil]
+  end
+end
+
+describe "The ternary operator" do
+  it "gets converted into an if statement with true and false parts" do
+    parsed("1 ? 2 : 3").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
+  end
+end

data/spec/cli/parser/iter_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Iters" do
+  describe "Iter on a command" do
+    it "the outer command call gets the iter" do
+      parsed("a b do; end").should == [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]], [:iter, nil]]
+      parsed("a 1, b do; end").should == [:call, nil, :a, [:arglist, [:int, 1], [:call, nil, :b, [:arglist]]], [:iter, nil]]
+    end
+  end
+
+  describe "with no args" do
+    it "has 'nil' as the args part of sexp" do
+      parsed("proc do; end")[4][1].should == nil
+    end
+  end
+
+  describe "with empty || args" do
+    it "should have args set to nil" do
+      parsed("proc do ||; end")[4][1].should == nil
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      parsed("proc do |a|; end")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      parsed("proc do |a, b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      parsed("proc do |a, b, c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with splat arg" do
+    it "adds a s(:masgn) for the s(:splat) even if its the only arg" do
+      parsed("proc do |*a|; end")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      parsed("proc do |a, *b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+  end
+
+  describe "with opt args" do
+    it "adds a s(:block) arg to end of s(:masgn) for each lasgn" do
+      parsed("proc do |a = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      parsed("proc do |a = 1, b = 2|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "should add lasgn block after all other args" do
+      parsed("proc do |a, b = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
+      parsed("proc do |b = 1, *c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+      parsed("proc do |b = 1, &c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
+    end
+  end
+
+  describe "with block arg" do
+    it "should add block arg with s(:block_pass) wrapping s(:lasgn) prefix" do
+      parsed("proc do |&a|; end")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+end

data/spec/cli/parser/lambda_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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
+
+  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(:lasgn) for 1 norm arg" do
+      parsed("->(a) {}")[4][1].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      parsed("-> (a, b) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      parsed("-> (a, b, c) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
+    end
+  end
+
+  describe "with optional braces" do
+    it "parses normal args" do
+      parsed("-> a {}")[4][1].should == [:lasgn, :a]
+      parsed("-> a, b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+    end
+
+    it "parses splat args" do
+      parsed("-> *a {}")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      parsed("-> a, *b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
+    end
+
+    it "parses opt args" do
+      parsed("-> a = 1 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
+      parsed("-> a = 1, b = 2 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
+    end
+
+    it "parses block args" do
+      parsed("-> &a {}")[4][1].should == [:masgn, [:array, [: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
+end

data/spec/cli/parser/literal_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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
+  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/cli/parser/masgn_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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/cli/parser/module_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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/cli/parser/not_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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 "rewrites as !(lhs == rhs)" do
+    parsed("1 != 2").should == [:call, [:call, [:int, 1], :==, [:arglist, [:int, 2]]], '!'.to_sym, [:arglist]]
+  end
+end
+
+describe "The '!~' expression" do
+  it "rewrites as !(lhs =~ rhs)" do
+    parsed("1 !~ 2").should == [:not, [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]]
+  end
+end

data/spec/cli/parser/op_asgn1_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+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