opal 0.5.5 → 0.6.0

data/spec/opal/parser/class_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe "The class keyword" do
-  it "returns an empty s(:block) when given an empty body" do
-    opal_parse('class A; end').should == [:class, :A, nil, [:block]]
-  end
-
-  it "does not place single expressions into a s(:block)" do
-    opal_parse('class A; 1; end').should == [:class, :A, nil, [:int, 1]]
-  end
-
-  it "adds multiple body expressions into a s(:block)" do
-    opal_parse('class A; 1; 2; end').should == [:class, :A, nil, [:block, [:int, 1], [:int, 2]]]
-  end
-
-  it "uses nil as a placeholder when no superclass is given" do
-    opal_parse('class A; end')[2].should == nil
-  end
-
-  it "reflects the given superclass" do
-    opal_parse('class A < B; end')[2].should == [:const, :B]
-  end
-
-  it "should accept just a constant for the class name" do
-    opal_parse('class A; end')[1].should == :A
-  end
-
-  it "should accept a prefix constant for the class name" do
-    opal_parse('class ::A; end')[1].should == [:colon3, :A]
-  end
-
-  it "should accept a nested constant for the class name" do
-    opal_parse('class A::B; end')[1].should == [:colon2, [:const, :A], :B]
-  end
-end

data/spec/opal/parser/const_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "Constants" do
-  it "should always become a s(:const)" do
-    opal_parse("FOO").should == [:const, :FOO]
-    opal_parse("BAR").should == [:const, :BAR]
-  end
-
-  it "should be returned as s(:cdecl) on assignment" do
-    opal_parse("FOO = 1").should == [:cdecl, :FOO, [:int, 1]]
-    opal_parse("FOO = BAR").should == [:cdecl, :FOO, [:const, :BAR]]
-  end
-end

data/spec/opal/parser/cvar_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe "Class variables" do
-  it "should always be returned as s(:cvar)" do
-    opal_parse("@@foo").should == [:cvar, :@@foo]
-  end
-
-  it "should always be converted to s(:cvdecl) on assignment" do
-    opal_parse("@@foo = 100").should == [:cvdecl, :@@foo, [:int, 100]]
-  end
-end

data/spec/opal/parser/def_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe "The def keyword" do
-  describe "for normal definitions" do
-    it "should return s(:def)" do
-      opal_parse("def a; end").should == [:def, nil, :a, [:args], [:block, [:nil]]]
-    end
-
-    it "adds s(:nil) on an empty body" do
-      opal_parse("def foo; end").last.should == [:block, [:nil]]
-    end
-  end
-
-  describe "for singleton definitions" do
-    it "should return s(:def)" do
-      opal_parse("def self.a; end").should == [:def, [:self], :a, [:args], [:block, [:nil]]]
-    end
-
-    it "adds s(:nil) on an empty body" do
-      opal_parse("def self.foo; end").last.should == [:block, [:nil]]
-    end
-  end
-
-  describe "with normal args" do
-    it "should list all args" do
-      opal_parse("def foo(a); end")[3].should == [:args, :a]
-      opal_parse("def foo(a, b); end")[3].should == [:args, :a, :b]
-      opal_parse("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
-      opal_parse("def foo(a = 1); end")[3].should == [:args, :a, [:block, [:lasgn, :a, [:int, 1]]]]
-      opal_parse("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
-      opal_parse("def foo(a, b = 1); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :b, [:int, 1]]]]
-      opal_parse("def foo(b = 1, *c); end")[3].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:int, 1]]]]
-      opal_parse("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
-      opal_parse("def foo(*a); end")[3].should == [:args, :"*a"]
-    end
-
-    it "uses '*' as an arg name for rest args without a name" do
-      opal_parse("def foo(*); end")[3].should == [:args, :"*"]
-    end
-  end
-
-  describe "with block arg" do
-    it "should list block argument with the '&' prefix" do
-      opal_parse("def foo(&a); end")[3].should == [:args, :"&a"]
-    end
-  end
-end
-

data/spec/opal/parser/false_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-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/opal/parser/file_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-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/opal/parser/gvar_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-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, [:int, 1]]
-    opal_parse("$: = 1").should == [:gasgn, :$:, [:int, 1]]
-  end
-end

data/spec/opal/parser/hash_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-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, [:int, 1], [:int, 2]]
-    opal_parse("{1 => 2, 3 => 4}").should == [:hash, [:int, 1], [:int, 2], [:int, 3], [:int, 4]]
-  end
-
-  it "supports 1.9 style hash keys" do
-    opal_parse("{ a: 1 }").should == [:hash, [:sym, :a], [:int, 1]]
-    opal_parse("{ a: 1, b: 2 }").should == [:hash, [:sym, :a], [:int, 1], [:sym, :b], [:int, 2]]
-  end
-end

data/spec/opal/parser/heredoc_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe "Heredocs" do
-
-  it "parses as a s(:str)" do
-    opal_parse("a = <<-FOO\nbar\nFOO")[2].should == [:str, "bar\n"]
-  end
-
-  it "allows start marker to be wrapped in quotes" do
-    opal_parse("a = <<-'FOO'\nbar\nFOO")[2].should == [:str, "bar\n"]
-    opal_parse("a = <<-\"FOO\"\nbar\nFOO")[2].should == [:str, "bar\n"]
-  end
-
-  it "does not parse EOS unless beginning of line" do
-    opal_parse("<<-FOO\ncontentFOO\nFOO").should == [:str, "contentFOO\n"]
-  end
-
-  it "does not parse EOS unless end of line" do
-    opal_parse("<<-FOO\nsome FOO content\nFOO").should == [:str, "some FOO content\n"]
-  end
-
-  it "parses postfix code as if it appeared after heredoc" do
-    opal_parse("<<-FOO.class\ncode\nFOO").should == [:call, [:str, "code\n"], :class, [:arglist]]
-    opal_parse("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/opal/parser/iasgn_spec.rb

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

data/spec/opal/parser/if_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-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, [:int, 1], [:int, 2], [:int, 3]]
-  end
-
-  it "uses nil as fasly body if not given else-then" do
-    opal_parse("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
-    opal_parse("if 1; 2; elsif 3; 4; else; 5; end").should == [:if, [:int, 1], [:int, 2], [:if, [:int, 3], [:int, 4], [:int, 5]]]
-    opal_parse("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
-    opal_parse("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
-    opal_parse("1 ? 2 : 3").should == [:if, [:int, 1], [:int, 2], [:int, 3]]
-  end
-end

data/spec/opal/parser/int_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "Parsing integers" do
-  it "parses integers as a s(:int) sexp" do
-    opal_parse("32").should == [:int, 32]
-  end
-end
-
-describe "Parsing floats" do
-  it "parses floats as a s(:float)" do
-    opal_parse("3.142").should == [:float, 3.142]
-  end
-end

data/spec/opal/parser/iter_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-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 == [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]], [:iter, nil]]
-      opal_parse("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
-      opal_parse("proc do; end")[4][1].should == nil
-    end
-  end
-
-  describe "with empty || args" do
-    it "should have args set to 0" do
-      opal_parse("proc do ||; end")[4][1].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")[4][1].should == [:lasgn, :a]
-    end
-
-    it "lists multiple norm args inside a s(:masgn)" do
-      opal_parse("proc do |a, b|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
-      opal_parse("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
-      opal_parse("proc do |*a|; end")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
-      opal_parse("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
-      opal_parse("proc do |a = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
-      opal_parse("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
-      opal_parse("proc do |a, b = 1|; end")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
-      opal_parse("proc do |b = 1, *c|; end")[4][1].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
-      opal_parse("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
-      opal_parse("proc do |&a|; end")[4][1].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
-    end
-  end
-end

data/spec/opal/parser/ivar_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-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/opal/parser/lambda_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe "Lambda literals" do
-  it "should parse with either do/end construct or curly braces" do
-    opal_parse("-> {}").first.should == :call
-    opal_parse("-> do; end").first.should == :call
-  end
-
-  it "should parse as a call to 'lambda' with the lambda body as a block" do
-    opal_parse("-> {}").should == [:call, nil, :lambda, [:arglist], [:iter, nil]]
-  end
-
-  describe "with no args" do
-    it "should accept no args" do
-      opal_parse("-> {}")[4][1].should == nil
-    end
-  end
-
-  describe "with normal args" do
-    it "adds a single s(:lasgn) for 1 norm arg" do
-      opal_parse("->(a) {}")[4][1].should == [:lasgn, :a]
-    end
-
-    it "lists multiple norm args inside a s(:masgn)" do
-      opal_parse("-> (a, b) {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
-      opal_parse("-> (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
-      opal_parse("-> a {}")[4][1].should == [:lasgn, :a]
-      opal_parse("-> a, b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
-    end
-
-    it "parses splat args" do
-      opal_parse("-> *a {}")[4][1].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
-      opal_parse("-> a, *b {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
-    end
-
-    it "parses opt args" do
-      opal_parse("-> a = 1 {}")[4][1].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
-      opal_parse("-> 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
-      opal_parse("-> &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
-      opal_parse("-> {}")[4][2].should == nil
-    end
-
-    it "should be the single sexp when given one statement" do
-      opal_parse("-> { 42 }")[4][2].should == [:int, 42]
-    end
-
-    it "should wrap multiple statements into a s(:block)" do
-      opal_parse("-> { 42; 3.142 }")[4][2].should == [:block, [:int, 42], [:float, 3.142]]
-    end
-  end
-end

data/spec/opal/parser/lasgn_spec.rb

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

data/spec/opal/parser/line_spec.rb

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

data/spec/opal/parser/lvar_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-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, [:int, 1]], [:lvar, :a]]
-      opal_parse("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
-      opal_parse("a").should == [:call, nil, :a, [:arglist]]
-      opal_parse("a = 1; b").should == [:block, [:lasgn, :a, [:int, 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 == [:def, nil, :a, [:args, :b], [:block, [:lvar, :b]]]
-      opal_parse("def a(b, c); c; end").should == [:def, nil, :a, [:args, :b, :c], [:block, [:lvar, :c]]]
-    end
-
-    it "should be created by an opt arg" do
-      opal_parse("def a(b=10); b; end").should == [:def, nil, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:block, [:lvar, :b]]]
-    end
-
-    it "should be created by a rest arg" do
-      opal_parse("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:block, [:lvar, :b]]]
-    end
-
-    it "should be created by a block arg" do
-      opal_parse("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [: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, [:int, 10]], [:def, nil, :b, [:args], [:block, [:call, nil, :a, [:arglist]]]]]
-    end
-  end
-end