opal 0.4.3 → 0.4.4

data/spec/parser/regexp_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe "Regexps" do
   it "parses a regexp as a s(:lit)" do
-    opal_parse("/lol/").should == [:lit, /lol/]
+    opal_parse("/lol/").should == [:regexp, /lol/]
   end
 
   it "parses regexp options" do
-    opal_parse("/lol/i").should == [:lit, /lol/i]
+    opal_parse("/lol/i").should == [:regexp, /lol/i]
   end
 
   it "can parse regexps using %r notation" do
-    opal_parse('%r(foo)').should == [:lit, /foo/]
-    opal_parse('%r(foo)i').should == [:lit, /foo/i]
+    opal_parse('%r(foo)').should == [:regexp, /foo/]
+    opal_parse('%r(foo)i').should == [:regexp, /foo/i]
   end
 end

data/spec/parser/return_spec.rb

@@ -6,12 +6,12 @@ describe "The return keyword" do
   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]]]
+    opal_parse("return 1").should == [:return, [:int, 1]]
+    opal_parse("return *2").should == [:return, [:splat, [:int, 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]]]]
+    opal_parse("return 1, 2").should == [:return, [:array, [:int, 1], [:int, 2]]]
+    opal_parse("return 1, *2").should == [:return, [:array, [:int, 1], [:splat, [:int, 2]]]]
   end
 end

data/spec/parser/sclass_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe "Singleton classes" do
-  pending "returns an empty s(:scope) when given an empty body" 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]]
+    opal_parse('class << A; 1; end')[2].should == [:scope, [:int, 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]]]
+    opal_parse('class << A; 1; 2; end')[2].should == [:scope, [:block, [:int, 1], [:int, 2]]]
   end
 
-  pending "should accept any expressions for singleton part" do
+  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

data/spec/parser/str_spec.rb

@@ -55,7 +55,7 @@ describe "Strings" do
       opal_parse('%Q{#@@foo}').should == [:dstr, "", [:evstr, [:cvar, :@@foo]]]
     end
 
-    pending "should match '{' and '}' pairs used to start string before ending match" do
+    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"]
@@ -65,7 +65,7 @@ describe "Strings" do
       opal_parse('%Q{a{b{c}#{foo}d}e}').should == [:dstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
     end
 
-    pending "should match '(' and ')' pairs used to start string before ending match" do
+    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"]
@@ -75,7 +75,7 @@ describe "Strings" do
       opal_parse('%Q(a(b(c)#{foo}d)e)').should == [:dstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
     end
 
-    pending "should match '[' and ']' pairs used to start string before ending match" do
+    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"]

data/spec/parser/super_spec.rb

@@ -6,15 +6,15 @@ describe "The super keyword" do
   end
 
   it "should return s(:super) for any arguments" do
-    opal_parse("super 1").should == [:super, [:lit, 1]]
-    opal_parse("super 1, 2").should == [:super, [:lit, 1], [:lit, 2]]
-    opal_parse("super 1, *2").should == [:super, [:lit, 1], [:splat, [:lit, 2]]]
+    opal_parse("super 1").should == [:super, [:int, 1]]
+    opal_parse("super 1, 2").should == [:super, [:int, 1], [:int, 2]]
+    opal_parse("super 1, *2").should == [:super, [:int, 1], [:splat, [:int, 2]]]
   end
 
   it "should always return s(:super) when parans are used" do
     opal_parse("super()").should == [:super]
-    opal_parse("super(1)").should == [:super, [:lit, 1]]
-    opal_parse("super(1, 2)").should == [:super, [:lit, 1], [:lit, 2]]
-    opal_parse("super(1, *2)").should == [:super, [:lit, 1], [:splat, [:lit, 2]]]
+    opal_parse("super(1)").should == [:super, [:int, 1]]
+    opal_parse("super(1, 2)").should == [:super, [:int, 1], [:int, 2]]
+    opal_parse("super(1, *2)").should == [:super, [:int, 1], [:splat, [:int, 2]]]
   end
 end

data/spec/parser/undef_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe "The undef keyword" do
   it "returns s(:undef) with the argument as an s(:lit)" do
-    opal_parse("undef a").should == [:undef, [:lit, :a]]
+    opal_parse("undef a").should == [:undef, [:sym, :a]]
   end
 
   it "appends multiple parts onto end of list" do
-    opal_parse("undef a, b").should == [:undef, [:lit, :a], [:lit, :b]]
+    opal_parse("undef a, b").should == [:undef, [:sym, :a], [:sym, :b]]
   end
 
   it "can take symbols or fitems" do
-    opal_parse("undef :foo").should == [:undef, [:lit, :foo]]
+    opal_parse("undef :foo").should == [:undef, [:sym, :foo]]
   end
 end

data/spec/parser/unless_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe "The unless keyword" do
   it "returns s(:if) with reversed true and false bodies" do
-    opal_parse("unless 10; 20; end").should == [:if, [:lit, 10], nil, [:lit, 20]]
-    opal_parse("unless 10; 20; 30; end").should == [:if, [:lit, 10], nil, [:block, [:lit, 20], [:lit, 30]]]
-    opal_parse("unless 10; 20; else; 30; end").should == [:if, [:lit, 10], [:lit, 30], [:lit, 20]]
+    opal_parse("unless 10; 20; end").should == [:if, [:int, 10], nil, [:int, 20]]
+    opal_parse("unless 10; 20; 30; end").should == [:if, [:int, 10], nil, [:block, [:int, 20], [:int, 30]]]
+    opal_parse("unless 10; 20; else; 30; end").should == [:if, [:int, 10], [:int, 30], [:int, 20]]
   end
 
   it "returns s(:if) with reversed true and false bodies for prefix unless" do
-    opal_parse("20 unless 10").should == [:if, [:lit, 10], nil, [:lit, 20]]
+    opal_parse("20 unless 10").should == [:if, [:int, 10], nil, [:int, 20]]
   end
 end

data/spec/parser/while_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe "The while keyword" do
   it "returns an s(:while) with the given expr, body and true for head" do
-    opal_parse("while 1; 2; end").should == [:while, [:lit, 1], [:lit, 2], true]
+    opal_parse("while 1; 2; end").should == [:while, [:int, 1], [:int, 2], true]
   end
 
   it "uses an s(:block) if body has more than one statement" do
-    opal_parse("while 1; 2; 3; end").should == [:while, [:lit, 1], [:block, [:lit, 2], [:lit, 3]], true]
+    opal_parse("while 1; 2; 3; end").should == [:while, [:int, 1], [:block, [:int, 2], [:int, 3]], true]
   end
 
   it "treats the prefix while statement just like a regular while statement" do
-    opal_parse("1 while 2").should == [:while, [:lit, 2], [:lit, 1], true]
+    opal_parse("1 while 2").should == [:while, [:int, 2], [:int, 1], true]
   end
 end

data/spec/parser/xstr_spec.rb

@@ -65,7 +65,7 @@ describe "x-strings" do
       opal_parse('%x{#@@foo}').should == [:dxstr, "", [:evstr, [:cvar, :@@foo]]]
     end
 
-    pending "should match '{' and '}' pairs used to start string before ending match" do
+    it "should match '{' and '}' pairs used to start string before ending match" do
       opal_parse('%x{{}}').should == [:xstr, "{}"]
       opal_parse('%x{foo{bar}baz}').should == [:xstr, "foo{bar}baz"]
       opal_parse('%x{{foo}bar}').should == [:xstr, "{foo}bar"]
@@ -75,7 +75,7 @@ describe "x-strings" do
       opal_parse('%x{a{b{c}#{foo}d}e}').should == [:dxstr, "a{b{c}", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d}e"]]
     end
 
-    pending "should match '(' and ')' pairs used to start string before ending match" do
+    it "should match '(' and ')' pairs used to start string before ending match" do
       opal_parse('%x(())').should == [:xstr, "()"]
       opal_parse('%x(foo(bar)baz)').should == [:xstr, "foo(bar)baz"]
       opal_parse('%x((foo)bar)').should == [:xstr, "(foo)bar"]
@@ -85,7 +85,7 @@ describe "x-strings" do
       opal_parse('%x(a(b(c)#{foo}d)e)').should == [:dxstr, "a(b(c)", [:evstr, [:call, nil, :foo, [:arglist]]], [:str, "d)e"]]
     end
 
-    pending "should match '[' and ']' pairs used to start string before ending match" do
+    it "should match '[' and ']' pairs used to start string before ending match" do
       opal_parse('%x[[]]').should == [:xstr, "[]"]
       opal_parse('%x[foo[bar]baz]').should == [:xstr, "foo[bar]baz"]
       opal_parse('%x[[foo]bar]').should == [:xstr, "[foo]bar"]

data/spec/parser/yield_spec.rb

@@ -6,15 +6,15 @@ describe "The yield keyword" do
   end
 
   it "appends arguments onto end of s(:yield) without an arglist" do
-    opal_parse("yield 1").should == [:yield, [:lit, 1]]
-    opal_parse("yield 1, 2").should == [:yield, [:lit, 1], [:lit, 2]]
-    opal_parse("yield 1, *2").should == [:yield, [:lit, 1], [:splat, [:lit, 2]]]
+    opal_parse("yield 1").should == [:yield, [:int, 1]]
+    opal_parse("yield 1, 2").should == [:yield, [:int, 1], [:int, 2]]
+    opal_parse("yield 1, *2").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
   end
 
   it "accepts parans for any number of arguments" do
     opal_parse("yield()").should == [:yield]
-    opal_parse("yield(1)").should == [:yield, [:lit, 1]]
-    opal_parse("yield(1, 2)").should == [:yield, [:lit, 1], [:lit, 2]]
-    opal_parse("yield(1, *2)").should == [:yield, [:lit, 1], [:splat, [:lit, 2]]]
+    opal_parse("yield(1)").should == [:yield, [:int, 1]]
+    opal_parse("yield(1, 2)").should == [:yield, [:int, 1], [:int, 2]]
+    opal_parse("yield(1, *2)").should == [:yield, [:int, 1], [:splat, [:int, 2]]]
   end
 end

data/spec/rubyspec/core/array/drop_spec.rb

@@ -7,7 +7,7 @@ ruby_version_is "1.9" do
     end
 
     it "raises an ArgumentError if the number of elements specified is negative" do
-     lambda { [1, 2].drop(-3) }.should raise_error(ArgumentError)
+      lambda { [1, 2].drop(-3) }.should raise_error(ArgumentError)
     end
 
     it "returns an empty Array if all elements are dropped" do

data/spec/rubyspec/core/array/keep_if_spec.rb

@@ -7,8 +7,6 @@ ruby_version_is "1.9" do
       array.keep_if { true }.should equal(array)
     end
 
-    pending do
-      it_behaves_like :keep_if, :keep_if
-    end
+    it_behaves_like :keep_if, :keep_if
   end
 end

data/spec/rubyspec/core/array/length_spec.rb

@@ -3,7 +3,5 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/length', __FILE__)
 
 describe "Array#length" do
-  pending do
-    it_behaves_like(:array_length, :length)
-  end
+  it_behaves_like(:array_length, :length)
 end

data/spec/rubyspec/core/array/map_spec.rb

@@ -3,13 +3,9 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/collect', __FILE__)
 
 describe "Array#map" do
-  pending do
-    it_behaves_like(:array_collect, :map)
-  end
+  it_behaves_like(:array_collect, :map)
 end
 
 describe "Array#map!" do
-  pending do
-    it_behaves_like(:array_collect_b, :map!)
-  end
+  it_behaves_like(:array_collect_b, :map!)
 end

data/spec/rubyspec/core/array/minus_spec.rb

@@ -47,7 +47,7 @@ describe "Array#-" do
     ([5, 6, 7] - ArraySpecs::ToAryArray[7]).should == [5, 6]
   end
 
-  pending "removes an item identified as equivalent via #hash and #eql?" do
+  it "removes an item identified as equivalent via #hash and #eql?" do
     obj1 = mock('1')
     obj2 = mock('2')
     obj1.should_receive(:hash).and_return(0)
@@ -57,7 +57,7 @@ describe "Array#-" do
     ([obj1] - [obj2]).should == []
   end
 
-  pending "doesn't remove an item with the same hash but not #eql?" do
+  it "doesn't remove an item with the same hash but not #eql?" do
     obj1 = mock('1')
     obj2 = mock('2')
     obj1.should_receive(:hash).and_return(0)
@@ -67,7 +67,7 @@ describe "Array#-" do
     ([obj1] - [obj2]).should == [obj1]
   end
 
-  pending "removes an identical item even when its #eql? isn't reflexive" do
+  it "removes an identical item even when its #eql? isn't reflexive" do
     x = mock('x')
     x.should_receive(:hash).any_number_of_times.and_return(42)
     x.stub!(:eql?).and_return(false) # Stubbed for clarity and latitude in implementation; not actually sent by MRI.

data/spec/rubyspec/core/array/multiply_spec.rb

@@ -3,31 +3,31 @@ require File.expand_path('../fixtures/classes', __FILE__)
 require File.expand_path('../shared/join', __FILE__)
 
 describe "Array#*" do
-  pending "tries to convert the passed argument to a String using #to_str" do
+  it "tries to convert the passed argument to a String using #to_str" do
     obj = mock('separator')
     obj.should_receive(:to_str).and_return('::')
     ([1, 2, 3, 4] * obj).should == '1::2::3::4'
   end
 
-  pending "tires to convert the passed argument to an Integer using #to_int" do
+  it "tires to convert the passed argument to an Integer using #to_int" do
     obj = mock('count')
     obj.should_receive(:to_int).and_return(2)
     ([1, 2, 3, 4] * obj).should == [1, 2, 3, 4, 1, 2, 3, 4]
   end
 
-  pending "raises a TypeError if the argument can neither be converted to a string nor an integer" do
+  it "raises a TypeError if the argument can neither be converted to a string nor an integer" do
     obj = mock('not a string or integer')
     lambda{ [1,2] * obj }.should raise_error(TypeError)
   end
 
-  pending "converts the passed argument to a String rather than an Integer" do
+  it "converts the passed argument to a String rather than an Integer" do
     obj = mock('2')
     def obj.to_int() 2 end
     def obj.to_str() "2" end
     ([:a, :b, :c] * obj).should == "a2b2c"
   end
 
-  pending "raises a TypeError is the passed argument is nil" do
+  it "raises a TypeError is the passed argument is nil" do
     lambda{ [1,2] * nil }.should raise_error(TypeError)
   end
 
@@ -64,7 +64,7 @@ describe "Array#* with an integer" do
     (array * 1).should == array
   end
 
-  pending "raises an ArgumentError when passed a negative integer" do
+  it "raises an ArgumentError when passed a negative integer" do
     lambda { [ 1, 2, 3 ] * -1 }.should raise_error(ArgumentError)
     lambda { [] * -1 }.should raise_error(ArgumentError)
   end
@@ -76,7 +76,7 @@ describe "Array#* with an integer" do
       @array = ArraySpecs::MyArray[1, 2, 3, 4, 5]
     end
 
-    pending "returns a subclass instance" do
+    it "returns a subclass instance" do
       (@array * 0).should be_an_instance_of(ArraySpecs::MyArray)
       (@array * 1).should be_an_instance_of(ArraySpecs::MyArray)
       (@array * 2).should be_an_instance_of(ArraySpecs::MyArray)
@@ -96,20 +96,20 @@ describe "Array#* with an integer" do
     end
   end
   ruby_version_is '1.9' do
-    pending "copies the taint status of the original array even if the passed count is 0" do
+    it "copies the taint status of the original array even if the passed count is 0" do
       ary = [1, 2, 3]
       ary.taint
       (ary * 0).tainted?.should == true
     end
   end
 
-  pending "copies the taint status of the original array even if the array is empty" do
+  it "copies the taint status of the original array even if the array is empty" do
     ary = []
     ary.taint
     (ary * 3).tainted?.should == true
   end
 
-  pending "copies the taint status of the original array if the passed count is not 0" do
+  it "copies the taint status of the original array if the passed count is not 0" do
     ary = [1, 2, 3]
     ary.taint
     (ary * 1).tainted?.should == true
@@ -117,19 +117,19 @@ describe "Array#* with an integer" do
   end
 
   ruby_version_is '1.9' do
-    pending "copies the untrusted status of the original array even if the passed count is 0" do
+    it "copies the untrusted status of the original array even if the passed count is 0" do
       ary = [1, 2, 3]
       ary.untrust
       (ary * 0).untrusted?.should == true
     end
 
-    pending "copies the untrusted status of the original array even if the array is empty" do
+    it "copies the untrusted status of the original array even if the array is empty" do
       ary = []
       ary.untrust
       (ary * 3).untrusted?.should == true
     end
 
-    pending "copies the untrusted status of the original array if the passed count is not 0" do
+    it "copies the untrusted status of the original array if the passed count is not 0" do
       ary = [1, 2, 3]
       ary.untrust
       (ary * 1).untrusted?.should == true
@@ -139,7 +139,5 @@ describe "Array#* with an integer" do
 end
 
 describe "Array#* with a string" do
-  pending do
-    it_behaves_like :array_join_with_string_separator, :*
-  end
+  it_behaves_like :array_join_with_string_separator, :*
 end

data/spec/rubyspec/core/array/new_spec.rb

@@ -6,7 +6,7 @@ describe "Array.new" do
     Array.new.should be_kind_of(Array)
   end
 
-  pending "returns an instance of a subclass" do
+  it "returns an instance of a subclass" do
     ArraySpecs::MyArray.new(1, 2).should be_an_instance_of(ArraySpecs::MyArray)
   end
 
@@ -66,7 +66,7 @@ describe "Array.new with (size, object=nil)" do
     a[1].should equal(obj)
   end
 
-  it "returns an array of size filled with nil when object is omitted" do    
+  it "returns an array of size filled with nil when object is omitted" do
     Array.new(3).should == [nil, nil, nil]
   end
 
@@ -75,7 +75,6 @@ describe "Array.new with (size, object=nil)" do
     lambda { Array.new(-1) }.should raise_error(ArgumentError)
   end
 
-  pending do
   platform_is :wordsize => 32 do
     it "raises an ArgumentError if size is too large" do
       max_size = ArraySpecs.max_32bit_size
@@ -89,7 +88,6 @@ describe "Array.new with (size, object=nil)" do
       lambda { Array.new(max_size + 1) }.should raise_error(ArgumentError)
     end
   end
-  end
 
   it "calls #to_int to convert the size argument to an Integer when object is given" do
     obj = mock('1')
@@ -111,7 +109,7 @@ describe "Array.new with (size, object=nil)" do
     obj2 = mock('nonnumeric')
     def obj2.to_int; "123"; end
     lambda{ Array.new(obj2, :a) }.should raise_error(TypeError)
-    
+
     obj3 = mock('nonnumeric')
     def obj3.to_int; 1.2; end
     lambda{ Array.new(obj3, :a) }.should raise_error(TypeError)