opal 0.3.11 → 0.3.15

data/spec/grammar/false_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The false keyword" do
+  it "should always return s(:false)" do
+    opal_parse("false").should == [:false]
+  end
+
+  it "cannot be assigned to" do
+    lambda {
+      opal_parse "true = 1"
+    }.should raise_error(Exception)
+
+    lambda {
+      opal_parse "true = true"
+    }.should raise_error(Exception)
+  end
+end

data/spec/grammar/file_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The __FILE__ keyword" do
+  it "should always return a s(:str) with given parser filename" do
+    opal_parse("__FILE__", "foo").should == [:str, "foo"]
+  end
+end

data/spec/grammar/gvar_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Global variables" do
+  it "should be returned as s(:gvar)" do
+    opal_parse("$foo").should == [:gvar, :$foo]
+    opal_parse("$:").should == [:gvar, :$:]
+  end
+
+  it "should return s(:gasgn) on assignment" do
+    opal_parse("$foo = 1").should == [:gasgn, :$foo, [:lit, 1]]
+    opal_parse("$: = 1").should == [:gasgn, :$:, [:lit, 1]]
+  end
+end

data/spec/grammar/hash_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Hash literals" do
+  it "without any assocs should return an empty hash sexp" do
+    opal_parse("{}").should == [:hash]
+  end
+
+  it "adds each assoc pair as individual args onto sexp" do
+    opal_parse("{1 => 2}").should == [:hash, [:lit, 1], [:lit, 2]]
+    opal_parse("{1 => 2, 3 => 4}").should == [:hash, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]]
+  end
+
+  it "supports 1.9 style hash keys" do
+    opal_parse("{ a: 1 }").should == [:hash, [:lit, :a], [:lit, 1]]
+    opal_parse("{ a: 1, b: 2 }").should == [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]]
+  end
+end

data/spec/grammar/iasgn_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Instance variable assignment" do
+  it "always returns an s(:iasgn)" do
+    opal_parse("@a = 1").should == [:iasgn, :@a, [:lit, 1]]
+    opal_parse("@A = 1").should == [:iasgn, :@A, [:lit, 1]]
+    opal_parse("@class = 1").should == [:iasgn, :@class, [:lit, 1]]
+  end
+end

data/spec/grammar/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
+    opal_parse("if 1; 2; else; 3; end").should == [:if, [:lit, 1], [:lit, 2], [:lit, 3]]
+  end
+
+  it "uses nil as fasly body if not given else-then" do
+    opal_parse("if 1; 2; end").should == [:if, [:lit, 1], [:lit, 2], nil]
+  end
+
+  it "is treats elsif parts as sub if expressions for else body" do
+    opal_parse("if 1; 2; elsif 3; 4; else; 5; end").should == [:if, [:lit, 1], [:lit, 2], [:if, [:lit, 3], [:lit, 4], [:lit, 5]]]
+    opal_parse("if 1; 2; elsif 3; 4; end").should == [:if, [:lit, 1], [:lit, 2], [:if, [:lit, 3], [:lit, 4], nil]]
+  end
+
+  it "returns a simple s(:if) with nil else body for prefix if statement" do
+    opal_parse("1 if 2").should == [:if, [:lit, 2], [:lit, 1], nil]
+  end
+end
+
+describe "The ternary operator" do
+  it "gets converted into an if statement with true and false parts" do
+    opal_parse("1 ? 2 : 3").should == [:if, [:lit, 1], [:lit, 2], [:lit, 3]]
+  end
+end

data/spec/grammar/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
+      opal_parse("a b do; end").should == [:iter, [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]]], nil]
+      opal_parse("a 1, b do; end").should == [:iter, [:call, nil, :a, [:arglist, [:lit, 1], [:call, nil, :b, [:arglist]]]], nil]
+    end
+  end
+
+  describe "with no args" do
+    it "has 'nil' as the args part of sexp" do
+      opal_parse("proc do; end")[2].should == nil
+    end
+  end
+
+  describe "with empty || args" do
+    it "should have args set to 0" do
+      opal_parse("proc do ||; end")[2].should == 0
+    end
+  end
+
+  describe "with normal args" do
+    it "adds a single s(:lasgn) for 1 norm arg" do
+      opal_parse("proc do |a|; end")[2].should == [:lasgn, :a]
+    end
+
+    it "lists multiple norm args inside a s(:masgn)" do
+      opal_parse("proc do |a, b|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
+      opal_parse("proc do |a, b, c|; end")[2].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
+      opal_parse("proc do |*a|; end")[2].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
+      opal_parse("proc do |a, *b|; end")[2].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
+      opal_parse("proc do |a = 1|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:lit, 1]]]]]
+      opal_parse("proc do |a = 1, b = 2|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]]]
+    end
+
+    it "should add lasgn block after all other args" do
+      opal_parse("proc do |a, b = 1|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:lit, 1]]]]]
+      opal_parse("proc do |b = 1, *c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:lit, 1]]]]]
+      opal_parse("proc do |b = 1, &c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:lit, 1]]]]]
+    end
+  end
+
+  describe "with block arg" do
+    it "should add block arg with s(:block_pass) wrapping s(:lasgn) prefix" do
+      opal_parse("proc do |&a|; end")[2].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
+    end
+  end
+end

data/spec/grammar/ivar_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Instance variables" do
+  it "always return an s(:ivar)" do
+    opal_parse("@a").should == [:ivar, :@a]
+    opal_parse("@A").should == [:ivar, :@A]
+    opal_parse("@class").should == [:ivar, :@class]
+  end
+end

data/spec/grammar/lasgn_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Local assignment" do
+  it "returns an s(:lasgn)" do
+    opal_parse("a = 1").should == [:lasgn, :a, [:lit, 1]]
+    opal_parse("a = 1; b = 2").should == [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]
+  end
+end

data/spec/grammar/line_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The __LINE__ keyword" do
+  it "should always return a literal number of the current line" do
+    opal_parse("__LINE__").should == [:lit, 1]
+    opal_parse("\n__LINE__").should == [:lit, 2]
+  end
+end

data/spec/grammar/lvar_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "An lvar" do
+  describe "in any scope" do
+    it "should be created when an identifier is previously assigned to" do
+      opal_parse("a = 1; a").should == [:block, [:lasgn, :a, [:lit, 1]], [:lvar, :a]]
+      opal_parse("a = 1; a; a").should == [:block, [:lasgn, :a, [:lit, 1]], [:lvar, :a], [:lvar, :a]]
+    end
+
+    it "should not be created when no lasgn is previously used on name" do
+      opal_parse("a").should == [:call, nil, :a, [:arglist]]
+      opal_parse("a = 1; b").should == [:block, [:lasgn, :a, [:lit, 1]], [:call, nil, :b, [:arglist]]]
+    end
+  end
+
+  describe "inside a def" do
+    it "should created by a norm arg" do
+      opal_parse("def a(b); b; end").should == [:defn, :a, [:args, :b], [:scope, [:block, [:lvar, :b]]]]
+      opal_parse("def a(b, c); c; end").should == [:defn, :a, [:args, :b, :c], [:scope, [:block, [:lvar, :c]]]]
+    end
+
+    it "should be created by an opt arg" do
+      opal_parse("def a(b=10); b; end").should == [:defn, :a, [:args, :b, [:block, [:lasgn, :b, [:lit, 10]]]], [:scope, [:block, [:lvar, :b]]]]
+    end
+
+    it "should be created by a rest arg" do
+      opal_parse("def a(*b); b; end").should == [:defn, :a, [:args, :"*b"], [:scope, [:block, [:lvar, :b]]]]
+    end
+
+    it "should be created by a block arg" do
+      opal_parse("def a(&b); b; end").should == [:defn, :a, [:args, :"&b"], [:scope, [:block, [:lvar, :b]]]]
+    end
+
+    it "should not be created from locals outside the def" do
+      opal_parse("a = 10; def b; a; end").should == [:block, [:lasgn, :a, [:lit, 10]], [:defn, :b, [:args], [:scope, [:block, [:call, nil, :a, [:arglist]]]]]]
+    end
+  end
+end

data/spec/grammar/module_spec.rb

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

data/spec/grammar/nil_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The nil keyword" do
+  it "always returns s(:nil)" do
+    opal_parse("nil").should == [:nil]
+  end
+
+  it "cannot be assigned to" do
+    lambda {
+      opal_parse "nil = 1"
+    }.should raise_error(Exception)
+
+    lambda {
+      opal_parse "nil = nil"
+    }.should raise_error(Exception)
+  end
+end

data/spec/grammar/not_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The not keyword" do
+  it "returns s(:not) with the single argument" do
+    opal_parse("not self").should == [:not, [:self]]
+    opal_parse("not 42").should == [:not, [:lit, 42]]
+  end
+end
+
+describe "The '!' expression" do
+  it "returns s(:not) with the single argument" do
+    opal_parse("!self").should == [:not, [:self]]
+    opal_parse("!42").should == [:not, [:lit, 42]]
+  end
+end
+
+describe "The '!=' expression" do
+  it "rewrites as !(lhs == rhs)" do
+    opal_parse("1 != 2").should == [:not, [:call, [:lit, 1], :==, [:arglist, [:lit, 2]]]]
+  end
+end
+
+describe "The '!~' expression" do
+  it "rewrites as !(lhs =~ rhs)" do
+    opal_parse("1 !~ 2").should == [:not, [:call, [:lit, 1], :=~, [:arglist, [:lit, 2]]]]
+  end
+end

data/spec/grammar/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
+    opal_parse('self[:foo] += 1')[0].should == :op_asgn1
+  end
+
+  it "correctly assigns the receiver" do
+    opal_parse("self[:foo] += 1")[1].should == [:self]
+  end
+
+  it "returns an arglist for args inside braces" do
+    opal_parse("self[:foo] += 1")[2].should == [:arglist, [:lit, :foo]]
+  end
+
+  it "only uses the operator, not with '=' appended" do
+    opal_parse("self[:foo] += 1")[3].should == :+
+  end
+
+  it "uses a simple sexp, not an arglist" do
+    opal_parse("self[:foo] += 1")[4].should == [:lit, 1]
+  end
+end

data/spec/grammar/op_asgn2_spec.rb

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

data/spec/grammar/or_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The or statement" do
+  it "should always return s(:or)" do
+    opal_parse("1 or 2").should == [:or, [:lit, 1], [:lit, 2]]
+  end
+end
+
+describe "The || expression" do
+  it "should always return s(:or)" do
+    opal_parse("1 || 2").should == [:or, [:lit, 1], [:lit, 2]]
+  end
+end

data/spec/grammar/return_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The return keyword" do
+  it "should return s(:return) when given no arguments" do
+    opal_parse("return").should == [:return]
+  end
+
+  it "returns s(:return) with the direct argument when given one argument" do
+    opal_parse("return 1").should == [:return, [:lit, 1]]
+    opal_parse("return *2").should == [:return, [:splat, [:lit, 2]]]
+  end
+
+  it "returns s(:return) with an s(:array) when args size > 1" do
+    opal_parse("return 1, 2").should == [:return, [:array, [:lit, 1], [:lit, 2]]]
+    opal_parse("return 1, *2").should == [:return, [:array, [:lit, 1], [:splat, [:lit, 2]]]]
+  end
+end

data/spec/grammar/sclass_spec.rb

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

data/spec/grammar/self_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "The self keyword" do
+  it "always returns s(:self)" do
+    opal_parse("self").should == [:self]
+  end
+
+  it "cannot be assigned to" do
+    lambda {
+      opal_parse "self = 1"
+    }.should raise_error(Exception)
+
+    lambda {
+      opal_parse "self = self"
+    }.should raise_error(Exception)
+  end
+end

data/spec/grammar/str_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Strings" do
+  it "parses empty strings" do
+    opal_parse('""').should == [:str, ""]
+    opal_parse("''").should == [:str, ""]
+  end
+
+  it "parses a simple string without interpolation as s(:str)" do
+    opal_parse('"foo # { } bar"').should == [:str, "foo # { } bar"]
+  end
+
+  it "does not interpolate with single quotes" do
+    opal_parse("'\#{foo}'").should == [:str, "\#{foo}"]
+    opal_parse("'\#@foo'").should == [:str, "\#@foo"]
+    opal_parse("'\#$foo'").should == [:str, "\#$foo"]
+    opal_parse("'\#@@foo'").should == [:str, "\#@@foo"]
+  end
+
+  it "supports interpolation with double quotes" do
+    opal_parse('"#{foo}"').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+    opal_parse('"#@foo"').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
+    opal_parse('"#$foo"').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
+    opal_parse('"#@@foo"').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
+  end
+
+  it "allows underscores in ivar, gvar and cvar interpolation" do
+    opal_parse('"#@foo_bar"').should == [:dstr, "", [:evstr, [:ivar, :@foo_bar]]]
+    opal_parse('"#$foo_bar"').should == [:dstr, "", [:evstr, [:gvar, :$foo_bar]]]
+    opal_parse('"#@@foo_bar"').should == [:dstr, "", [:evstr, [:cvar, :@@foo_bar]]]
+  end
+
+  describe "from %Q construction" do
+    it "can use '[', '(' or '{' matching pairs for string boundry" do
+      opal_parse('%Q{foo}').should == [:str, "foo"]
+      opal_parse('%Q[foo]').should == [:str, "foo"]
+      opal_parse('%Q(foo)').should == [:str, "foo"]
+    end
+
+    it "can parse empty strings" do
+      opal_parse('%Q{}').should == [:str, ""]
+      opal_parse('%Q[]').should == [:str, ""]
+      opal_parse('%Q()').should == [:str, ""]
+    end
+
+    it "should allow interpolation" do
+      opal_parse('%Q(#{foo})').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+      opal_parse('%Q[#{foo}]').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+      opal_parse('%Q{#{foo}}').should == [:dstr, "", [:evstr, [:call, nil, :foo, [:arglist]]]]
+    end
+
+    it "should allow ivar, gvar and cvar interpolation" do
+      opal_parse('%Q{#@foo}').should == [:dstr, "", [:evstr, [:ivar, :@foo]]]
+      opal_parse('%Q{#$foo}').should == [:dstr, "", [:evstr, [:gvar, :$foo]]]
+      opal_parse('%Q{#@@foo}').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
+    end
+
+    it "should match '{' and '}' pairs used to start string before ending match" do
+      opal_parse('%Q{{}}').should == [:str, "{}"]
+      opal_parse('%Q{foo{bar}baz}').should == [:str, "foo{bar}baz"]
+      opal_parse('%Q{{foo}bar}').should == [:str, "{foo}bar"]
+      opal_parse('%Q{foo{bar}}').should == [:str, "foo{bar}"]
+      opal_parse('%Q{foo#{bar}baz}').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      opal_parse('%Q{a{b{c}d{e}f}g}').should == [:str, "a{b{c}d{e}f}g"]
+      opal_parse('%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
+      opal_parse('%Q(())').should == [:str, "()"]
+      opal_parse('%Q(foo(bar)baz)').should == [:str, "foo(bar)baz"]
+      opal_parse('%Q((foo)bar)').should == [:str, "(foo)bar"]
+      opal_parse('%Q(foo(bar))').should == [:str, "foo(bar)"]
+      opal_parse('%Q(foo#{bar}baz)').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      opal_parse('%Q(a(b(c)d(e)f)g)').should == [:str, "a(b(c)d(e)f)g"]
+      opal_parse('%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
+      opal_parse('%Q[[]]').should == [:str, "[]"]
+      opal_parse('%Q[foo[bar]baz]').should == [:str, "foo[bar]baz"]
+      opal_parse('%Q[[foo]bar]').should == [:str, "[foo]bar"]
+      opal_parse('%Q[foo[bar]]').should == [:str, "foo[bar]"]
+      opal_parse('%Q[foo#{bar}baz]').should == [:dstr, "foo", [:evstr, [:call, nil, :bar, [:arglist]]], [:str, "baz"]]
+      opal_parse('%Q[a[b[c]d[e]f]g]').should == [:str, "a[b[c]d[e]f]g"]
+      opal_parse('%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
+      opal_parse('%Q{#{each { nil } }}').should == [:dstr, "", [:evstr, [:iter, [:call, nil, :each, [:arglist]], nil, [:nil]]]]
+    end
+
+    it "parses other Qstrings within interpolations" do
+      opal_parse('%Q{#{ %Q{} }}').should == [:dstr, "", [:evstr, [:str, ""]]]
+    end
+  end
+end