opal 0.4.4 → 0.5.0

data/spec/corelib/runtime/method_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module OpalMethodSpec
+  class C
+    def foo; :C; end
+  end
+
+  module M
+    def foo; :M; end
+    def bar; :M; end
+  end
+
+  module N
+    def bar; :N; end
+  end
+
+  class C
+    include M
+    include N
+  end
+end
+
+describe "Including modules in a class with methods already defined in class" do
+  it "should always call the method defined in a class first" do
+    OpalMethodSpec::C.new.foo.should == :C
+  end
+
+  it "should call the method from the last module included unless class defines method" do
+    OpalMethodSpec::C.new.bar.should == :N
+  end
+end

data/spec/corelib/runtime/paren_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Parens" do
+  it "can be used to group expressions" do
+    (self.class; self.to_s; 42).should == 42
+    (3.142).should == 3.142
+    ().should == nil
+  end
+
+  it "generates code that contains the expression in precedence" do
+    foo = 100
+    ((foo += 42) == 142).should == true
+  end
+end

data/spec/{opal/language → corelib/runtime}/rescue_spec.rb

@@ -17,6 +17,13 @@ class RescueReturningSpec
       :bar
     end
   end
+
+  def empty_rescue
+    begin
+      raise "ERROR"
+    rescue
+    end
+  end
 end
 
 describe "The rescue keyword" do
@@ -24,4 +31,8 @@ describe "The rescue keyword" do
     RescueReturningSpec.new.single.should == :foo
     RescueReturningSpec.new.multiple.should == :bar
   end
+
+  it "returns nil if no expr given in rescue body" do
+    RescueReturningSpec.new.empty_rescue.should be_nil
+  end
 end

data/spec/{opal/language → corelib/runtime}/super_spec.rb

@@ -21,6 +21,10 @@ class SingletonMethodSuperSpec
     block_given?
   end
 
+  def with_splat_args(*a)
+    a
+  end
+
   class A < SingletonMethodSuperSpec
     def passing_block(*a)
       super
@@ -37,6 +41,10 @@ class SingletonMethodSuperSpec
     def self.super_args(*a)
       super()
     end
+
+    def with_splat_args
+      super 2, *[3, 4]
+    end
   end
 end
 
@@ -91,9 +99,114 @@ describe "The 'super' keyword" do
     end
   end
 
+  it "handles splat args" do
+    SingletonMethodSuperSpec::A.new.with_splat_args.should == [2, 3, 4]
+  end
+
   describe "inside a class body" do
     it "does not break when multiple super statements are in body" do
       lambda { MultipleSuperSpec.new.to_s }.should_not raise_error
     end
   end
 end
+
+
+module OpalSuperSpecs
+  class A
+    def foo
+      'a'
+    end
+
+    def self.bar
+      'x'
+    end
+  end
+
+  class B < A
+    def foo
+      super + 'b'
+    end
+
+    def self.bar
+      super + 'y'
+    end
+  end
+
+  class C < B
+    def foo
+      super + 'c'
+    end
+
+    def self.bar
+      super + 'z'
+    end
+  end
+
+  module M1
+    def chain(out)
+      out << 'M1'
+    end
+  end
+
+  module M2
+    def chain(out)
+      out << 'M2'
+      super out
+    end
+  end
+
+  module M3
+    def chain(out)
+      out << 'M3'
+      super out
+    end
+  end
+
+  class C1
+    include M1
+    include M2
+    include M3
+  end
+
+  class C2
+    include M1
+    include M2
+
+    def chain(out)
+      out << 'C2'
+      super out
+    end
+  end
+
+  class C3
+    def chain(out)
+      out << 'C3'
+    end
+  end
+
+  class C4 < C3
+    include M2
+  end
+end
+
+describe "Super chains" do
+  it "searches entire class hierarchys for instance methods" do
+    OpalSuperSpecs::C.new.foo.should == 'abc'
+  end
+
+  it "searches entire class hierarchys for class methods" do
+    OpalSuperSpecs::C.bar.should == 'xyz'
+  end
+
+  it "calls methods for every module included in a class" do
+    OpalSuperSpecs::C1.new.chain([]).should == ['M3', 'M2', 'M1']
+  end
+
+  it "calls method defined in class before modules" do
+    OpalSuperSpecs::C2.new.chain([]).should == ['C2', 'M2', 'M1']
+  end
+
+  it "calls method defined on superclass after modules included by child" do
+    OpalSuperSpecs::C4.new.chain([]).should == ['M2', 'C3']
+  end
+end

data/spec/{opal → corelib}/source_map_spec.rb

@@ -4,9 +4,9 @@ require 'opal-source-maps'
 describe Opal::SourceMap do
   before do
     pathname = 'foo.rb'
-    parser   = Opal::Parser.new
-    @source  = parser.parse("1 + 1", pathname)
-    @map     = Opal::SourceMap.new(parser.fragments, pathname)
+    compiler = Opal::Compiler.new
+    @source  = compiler.compile("1 + 1", :file => pathname)
+    @map     = Opal::SourceMap.new(compiler.fragments, pathname)
   end
 
   it 'does not blow while generating the map' do

data/spec/{rubyspec/core → corelib}/string/element_reference_spec.rb

@@ -1,4 +1,3 @@
-require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe "String#[]" do

data/spec/{rubyspec/core → corelib}/string/ljust_spec.rb

@@ -1,5 +1,4 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../fixtures/classes.rb', __FILE__)
 
 describe "String#ljust" do

data/spec/{rubyspec/core → corelib}/string/rjust_spec.rb

@@ -1,5 +1,4 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../fixtures/classes.rb', __FILE__)
 
 describe "String#rjust with length, padding" do

data/spec/{rubyspec/core → corelib}/string/slice_spec.rb

@@ -1,4 +1,3 @@
-require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe "String#slice" do
@@ -72,4 +71,4 @@ describe "String#slice with index, length" do
     "x".slice(-2, 0).should == nil
     "x".slice(-2, 1).should == nil
   end
-end
+end

data/spec/filters/bugs/array.rb

@@ -1,5 +1,237 @@
-opal_filter "arrays" do
-  fails "The unpacking splat operator (*) returns a new array containing the same values when applied to an array inside an empty array"
-  fails "The unpacking splat operator (*) unpacks the start and count arguments in an array slice assignment"
-  fails "The unpacking splat operator (*) unpacks arguments as if they were listed statically"
+opal_filter "Array" do
+  fails "Array#clone copies singleton methods"
+  fails "Array#clone creates a new array containing all elements or the original"
+
+  fails "Array#collect! returns an Enumerator when no block given, and the enumerator can modify the original array"
+
+  fails "Array#combination generates from a defensive copy, ignoring mutations"
+  fails "Array#combination yields a partition consisting of only singletons"
+  fails "Array#combination yields [] when length is 0"
+  fails "Array#combination yields a copy of self if the argument is the size of the receiver"
+  fails "Array#combination yields nothing if the argument is out of bounds"
+  fails "Array#combination yields the expected combinations"
+  fails "Array#combination yields nothing for out of bounds length and return self"
+  fails "Array#combination returns self when a block is given"
+  fails "Array#combination returns an enumerator when no block is provided"
+
+  fails "Array#<=> calls <=> left to right and return first non-0 result"
+  fails "Array#<=> returns -1 if the arrays have same length and a pair of corresponding elements returns -1 for <=>"
+  fails "Array#<=> returns +1 if the arrays have same length and a pair of corresponding elements returns +1 for <=>"
+  fails "Array#<=> properly handles recursive arrays"
+  fails "Array#<=> tries to convert the passed argument to an Array using #to_ary"
+  fails "Array#<=> returns nil when the argument is not array-like"
+
+  fails "Array#concat tries to convert the passed argument to an Array using #to_ary"
+  fails "Array#concat is not infected by the other"
+
+  fails "Array#delete_at tries to convert the passed argument to an Integer using #to_int"
+
+  fails "Array#delete_if returns an Enumerator if no block given, and the enumerator can modify the original array"
+
+  fails "Array#delete may be given a block that is executed if no element matches object"
+  fails "Array#delete returns the last element in the array for which object is equal under #=="
+
+  fails "Array#drop_while removes elements from the start of the array until the block returns false"
+  fails "Array#drop_while removes elements from the start of the array until the block returns nil"
+  fails "Array#drop_while removes elements from the start of the array while the block evaluates to true"
+
+  fails "Array#dup creates a new array containing all elements or the original"
+
+  fails "Array#[] tries to convert the passed argument to an Integer using #to_int"
+  fails "Array#[] accepts Range instances having a negative m and both signs for n with [m..n] and [m...n]"
+  fails "Array#[] tries to convert Range elements to Integers using #to_int with [m..n] and [m...n]"
+  fails "Array#[] returns nil if range start is not in the array with [m..n]"
+  fails "Array#[] raises a RangeError when the start index is out of range of Fixnum"
+  fails "Array#[] raises a RangeError when the start index is out of range of Fixnum"
+  fails "Array#[] raises a RangeError when the length is out of range of Fixnum"
+  fails "Array#[] raises a RangeError when the length is out of range of Fixnum"
+  fails "Array.[] can unpack 2 or more nested referenced array"
+
+  fails "Array#[]= calls to_ary on its rhs argument for multi-element sets"
+  fails "Array#[]= raises an IndexError when passed indexes out of bounds"
+  fails "Array#[]= tries to convert Range elements to Integers using #to_int with [m..n] and [m...n]"
+
+  fails "Array#[]= with [m..n] accepts Range subclasses"
+  fails "Array#[]= with [m..n] inserts the other section at m if m > n"
+  fails "Array#[]= with [m..n] replaces the section if m < 0 and n > 0"
+  fails "Array#[]= with [m..n] replaces the section if m and n < 0"
+  fails "Array#[]= with [m..n] just sets the section defined by range to nil if m and n < 0 and the rhs is nil"
+
+  fails "Array#[]= sets elements in the range arguments when passed ranges"
+  fails "Array#[]= calls to_int on its start and length arguments"
+  fails "Array#[]= does nothing if the section defined by range has negative width and the rhs is an empty array"
+
+  fails "Array#eql? ignores array class differences"
+  fails "Array#eql? handles well recursive arrays"
+  fails "Array#eql? returns true if corresponding elements are #eql?"
+
+  fails "Array#== compares with an equivalent Array-like object using #to_ary"
+  fails "Array#== handles well recursive arrays"
+
+  fails "Array#fetch tries to convert the passed argument to an Integer using #to_int"
+  fails "Array#fetch raises a TypeError when the passed argument can't be coerced to Integer"
+
+  fails "Array#first tries to convert the passed argument to an Integer using #to_int"
+  fails "Array#first raises a TypeError if the passed argument is not numeric"
+
+  fails "Array#flatten does not call flatten on elements"
+  fails "Array#flatten raises an ArgumentError on recursive arrays"
+  fails "Array#flatten with a non-Array object in the Array ignores the return value of #to_ary if it is nil"
+  fails "Array#flatten with a non-Array object in the Array raises a TypeError if the return value of #to_ary is not an Array"
+  fails "Array#flatten raises a TypeError when the passed Object can't be converted to an Integer"
+  fails "Array#flatten tries to convert passed Objects to Integers using #to_int"
+
+  fails "Array#flatten! does not call flatten! on elements"
+  fails "Array#flatten! raises an ArgumentError on recursive arrays"
+  fails "Array#flatten! flattens any elements which responds to #to_ary, using the return value of said method"
+  fails "Array#flatten! raises a TypeError when the passed Object can't be converted to an Integer"
+  fails "Array#flatten! tries to convert passed Objects to Integers using #to_int"
+  fails "Array#flatten! should not check modification by size"
+
+  fails "Array#initialize with (size, object=nil) sets the array to the values returned by the block before break is executed"
+  fails "Array#initialize with (size, object=nil) returns the value passed to break"
+  fails "Array#initialize with (size, object=nil) uses the block value instead of using the default value"
+  fails "Array#initialize with (size, object=nil) yields the index of the element and sets the element to the value of the block"
+  fails "Array#initialize with (size, object=nil) raises a TypeError if the size argument is not an Integer type"
+  fails "Array#initialize with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is not given"
+  fails "Array#initialize with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is given"
+  fails "Array#initialize with (size, object=nil) raises an ArgumentError if size is too large"
+  fails "Array#initialize with (size, object=nil) sets the array to size and fills with the object"
+  fails "Array#initialize with (array) calls #to_ary to convert the value to an array"
+  fails "Array#initialize preserves the object's identity even when changing its value"
+
+  fails "Array#insert tries to convert the passed position argument to an Integer using #to_int"
+
+  fails "Array#join raises an ArgumentError when the Array is recursive"
+  fails "Array#join raises a NoMethodError if an element does not respond to #to_str, #to_ary, or #to_s"
+  fails "Array#join attempts coercion via #to_str first"
+  fails "Array#join attempts coercion via #to_ary second"
+  fails "Array#join attempts coercion via #to_s third"
+  fails "Array#join separates elements with default separator when the passed separator is nil"
+  fails "Array#join returns a string formed by concatenating each String element separated by $,"
+  fails "Array#join uses the same separator with nested arrays"
+  fails "Array#join returns a string formed by concatenating each element.to_str separated by separator"
+
+  fails "Array#& properly handles recursive arrays"
+  fails "Array#& tries to convert the passed argument to an Array using #to_ary"
+  fails "Array#& determines equivalence between elements in the sense of eql?"
+
+  fails "Array#join calls #to_str to convert the separator to a String"
+  fails "Array#join does not call #to_str on the separator if the array is empty"
+  fails "Array#join raises a TypeError if the separator cannot be coerced to a String by calling #to_str"
+  fails "Array#join raises a TypeError if passed false as the separator"
+
+  fails "Array#last tries to convert the passed argument to an Integer usinig #to_int"
+
+  fails "Array#map! returns an Enumerator when no block given, and the enumerator can modify the original array"
+
+  fails "Array#- removes an identical item even when its #eql? isn't reflexive"
+  fails "Array#- doesn't remove an item with the same hash but not #eql?"
+  fails "Array#- removes an item identified as equivalent via #hash and #eql?"
+  fails "Array#- tries to convert the passed arguments to Arrays using #to_ary"
+
+  fails "Array#* raises a TypeError is the passed argument is nil"
+  fails "Array#* converts the passed argument to a String rather than an Integer"
+  fails "Array#* raises a TypeError if the argument can neither be converted to a string nor an integer"
+  fails "Array#* tires to convert the passed argument to an Integer using #to_int"
+  fails "Array#* tries to convert the passed argument to a String using #to_str"
+  fails "Array#* with a string uses the same separator with nested arrays"
+  fails "Array#* with a string returns a string formed by concatenating each element.to_str separated by separator"
+
+  fails "Array.new with (size, object=nil) raises an ArgumentError if size is too large"
+  fails "Array.new with (array) calls #to_ary to convert the value to an array"
+  fails "Array.new with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is given"
+  fails "Array.new with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is not given"
+  fails "Array.new with (size, object=nil) raises a TypeError if the size argument is not an Integer type"
+
+  fails "Array#+ tries to convert the passed argument to an Array using #to_ary"
+
+  fails "Array#pop passed a number n as an argument raises an ArgumentError if more arguments are passed"
+  fails "Array#pop passed a number n as an argument raises a TypeError when the passed n can be coerced to Integer"
+  fails "Array#pop passed a number n as an argument tries to convert n to an Integer using #to_int"
+
+  fails "Array#rassoc does not check the last element in each contained but speficically the second"
+  fails "Array#rassoc calls elem == obj on the second element of each contained array"
+
+  fails "Array#replace tries to convert the passed argument to an Array using #to_ary"
+
+  fails "Array#rindex rechecks the array size during iteration"
+
+  fails "Array#select returns a new array of elements for which block is true"
+
+  fails "Array#shift passed a number n as an argument raises an ArgumentError if more arguments are passed"
+  fails "Array#shift passed a number n as an argument raises a TypeError when the passed n can be coerced to Integer"
+  fails "Array#shift passed a number n as an argument tries to convert n to an Integer using #to_int"
+  fails "Array#shift passed a number n as an argument raises an ArgumentError if n is negative"
+  fails "Array#shift passed a number n as an argument returns a new empty array if there are no more elements"
+
+  fails "Array#shuffle uses given random generator"
+  fails "Array#shuffle uses default random generator"
+  fails "Array#shuffle attempts coercion via #to_hash"
+  fails "Array#shuffle is not destructive"
+  fails "Array#shuffle returns the same values, in a usually different order"
+  fails "Array#shuffle calls #rand on the Object passed by the :random key in the arguments Hash"
+  fails "Array#shuffle ignores an Object passed for the RNG if it does not define #rand"
+  fails "Array#shuffle accepts a Float for the value returned by #rand"
+  fails "Array#shuffle calls #to_int on the Object returned by #rand"
+  fails "Array#shuffle raises a RangeError if the value is less than zero"
+  fails "Array#shuffle raises a RangeError if the value is equal to one"
+
+  fails "Array#shuffle! returns the same values, in a usually different order"
+
+  fails "Array#slice raises a RangeError when the length is out of range of Fixnum"
+  fails "Array#slice raises a RangeError when the start index is out of range of Fixnum"
+  fails "Array#slice returns nil if range start is not in the array with [m..n]"
+  fails "Array#slice tries to convert Range elements to Integers using #to_int with [m..n] and [m...n]"
+  fails "Array#slice accepts Range instances having a negative m and both signs for n with [m..n] and [m...n]"
+  fails "Array#slice tries to convert the passed argument to an Integer using #to_int"
+
+  fails "Array#slice! does not expand array with negative indices out of bounds"
+  fails "Array#slice! does not expand array with indices out of bounds"
+  fails "Array#slice! calls to_int on range arguments"
+  fails "Array#slice! removes and return elements in range"
+  fails "Array#slice! calls to_int on start and length arguments"
+
+  fails "Array#transpose raises a TypeError if the passed Argument does not respond to #to_ary"
+  fails "Array#transpose tries to convert the passed argument to an Array using #to_ary"
+
+  fails "Array.try_convert does not rescue exceptions raised by #to_ary"
+  fails "Array.try_convert sends #to_ary to the argument and raises TypeError if it's not a kind of Array"
+  fails "Array.try_convert sends #to_ary to the argument and returns the result if it's a kind of Array"
+  fails "Array.try_convert sends #to_ary to the argument and returns the result if it's an Array"
+  fails "Array.try_convert sends #to_ary to the argument and returns the result if it's nil"
+
+  fails "Array#uniq compares elements based on the value returned from the block"
+  fails "Array#uniq compares elements with matching hash codes with #eql?"
+  fails "Array#uniq uses eql? semantics"
+
+  fails "Array#uniq! compares elements based on the value returned from the block"
+  fails "Array#uniq! properly handles recursive arrays"
+
+  fails "Array#values_at returns an array of elements at the indexes when passed indexes"
+  fails "Array#values_at calls to_int on its indices"
+  fails "Array#values_at returns an array of elements in the ranges when passes ranges"
+  fails "Array#values_at properly handles recursive arrays"
+  fails "Array#values_at calls to_int on arguments of ranges when passes ranges"
+
+  fails "Array#zip calls #to_ary to convert the argument to an Array"
+  fails "Array#zip uses #each to extract arguments' elements when #to_ary fails"
+
+  fails "Array#hash returns the same value if arrays are #eql?"
+  fails "Array#hash returns same hash code for arrays with the same content"
+  fails "Array#hash ignores array class differences"
+  fails "Array#hash calls to_int on result of calling hash on each element"
+  fails "Array#hash returns the same hash for equal recursive arrays through hashes"
+  fails "Array#hash returns the same hash for equal recursive arrays"
+  fails "Array#hash returns the same fixnum for arrays with the same content"
+
+  fails "Array#initialize_copy tries to convert the passed argument to an Array using #to_ary"
+  fails "Array#initialize_copy does not make self dependent to the original array"
+  fails "Array#initialize_copy returns self"
+  fails "Array#initialize_copy properly handles recursive arrays"
+  fails "Array#initialize_copy replaces the elements with elements from other array"
+
+  fails "Array#partition properly handles recursive arrays"
+  fails "Array#partition returns in the left array values for which the block evaluates to true"
+  fails "Array#partition returns two arrays"
 end