opal 0.8.1 → 0.9.0.beta1

data/opal/corelib/unsupported.rb

@@ -0,0 +1,216 @@
+%x{
+  var warnings = {};
+
+  function warn(string) {
+    if (warnings[string]) {
+      return;
+    }
+
+    warnings[string] = true;
+    #{warn(`string`)};
+  }
+}
+
+class String
+  `var ERROR = "String#%s not supported. Mutable String methods are not supported in Opal.";`
+
+  def <<(*)
+    raise NotImplementedError, `ERROR` % '<<'
+  end
+
+  def capitalize!(*)
+    raise NotImplementedError, `ERROR` % 'capitalize!'
+  end
+
+  def chomp!(*)
+    raise NotImplementedError, `ERROR` % 'chomp!'
+  end
+
+  def chop!(*)
+    raise NotImplementedError, `ERROR` % 'chop!'
+  end
+
+  def downcase!(*)
+    raise NotImplementedError, `ERROR` % 'downcase!'
+  end
+
+  def gsub!(*)
+    raise NotImplementedError, `ERROR` % 'gsub!'
+  end
+
+  def lstrip!(*)
+    raise NotImplementedError, `ERROR` % 'lstrip!'
+  end
+
+  def next!(*)
+    raise NotImplementedError, `ERROR` % 'next!'
+  end
+
+  def reverse!(*)
+    raise NotImplementedError, `ERROR` % 'reverse!'
+  end
+
+  def slice!(*)
+    raise NotImplementedError, `ERROR` % 'slice!'
+  end
+
+  def squeeze!(*)
+    raise NotImplementedError, `ERROR` % 'squeeze!'
+  end
+
+  def strip!(*)
+    raise NotImplementedError, `ERROR` % 'strip!'
+  end
+
+  def sub!(*)
+    raise NotImplementedError, `ERROR` % 'sub!'
+  end
+
+  def succ!(*)
+    raise NotImplementedError, `ERROR` % 'succ!'
+  end
+
+  def swapcase!(*)
+    raise NotImplementedError, `ERROR` % 'swapcase!'
+  end
+
+  def tr!(*)
+    raise NotImplementedError, `ERROR` % 'tr!'
+  end
+
+  def tr_s!(*)
+    raise NotImplementedError, `ERROR` % 'tr_s!'
+  end
+
+  def upcase!(*)
+    raise NotImplementedError, `ERROR` % 'upcase!'
+  end
+end
+
+module Kernel
+  `var ERROR = "Object freezing is not supported by Opal";`
+
+  def freeze
+    if `OPAL_CONFIG.freezing`
+      `warn(ERROR)`
+    else
+      raise NotImplementedError, `ERROR`
+    end
+
+    self
+  end
+
+  def frozen?
+    if `OPAL_CONFIG.freezing`
+      `warn(ERROR)`
+    else
+      raise NotImplementedError, `ERROR`
+    end
+
+    false
+  end
+end
+
+module Kernel
+  `var ERROR = "Object tainting is not supported by Opal";`
+
+  def taint
+    if `OPAL_CONFIG.tainting`
+      `warn(ERROR)`
+    else
+      raise NotImplementedError, `ERROR`
+    end
+
+    self
+  end
+
+  def untaint
+    if `OPAL_CONFIG.tainting`
+      `warn(ERROR)`
+    else
+      raise NotImplementedError, `ERROR`
+    end
+
+    self
+  end
+
+  def tainted?
+    if `OPAL_CONFIG.tainting`
+      `warn(ERROR)`
+    else
+      raise NotImplementedError, `ERROR`
+    end
+
+    false
+  end
+end
+
+module Marshal
+  `var ERROR = "Marshalling is not supported by Opal";`
+
+  module_function
+
+  def dump(*)
+    raise NotImplementedError, `ERROR`
+  end
+
+  def load(*)
+    raise NotImplementedError, `ERROR`
+  end
+
+  def restore(*)
+    raise NotImplementedError, `ERROR`
+  end
+end
+
+class Module
+  def public(*methods)
+    %x{
+      if (methods.length === 0) {
+        self.$$module_function = false;
+      }
+
+      return nil;
+    }
+  end
+
+  alias private public
+
+  alias protected public
+
+  alias nesting public
+
+  def private_class_method(name)
+    `self['$' + name] || nil`
+  end
+
+  alias public_class_method private_class_method
+
+  def private_method_defined?(obj)
+    false
+  end
+
+  def private_constant(*)
+  end
+
+  alias protected_method_defined? private_method_defined?
+
+  alias public_instance_methods instance_methods
+
+  alias public_method_defined? method_defined?
+end
+
+module Kernel
+  def private_methods(*)
+    []
+  end
+
+  alias private_instance_methods private_methods
+end
+
+module Kernel
+  def eval(*)
+    raise NotImplementedError, "To use Kernel#eval, you must first require 'opal-parser'. "\
+                               "See https://github.com/opal/opal/blob/#{RUBY_ENGINE_VERSION}/docs/opal_parser.md for details."
+  end
+end

data/opal/corelib/variables.rb

@@ -16,9 +16,3 @@ ENV  = {}
 $VERBOSE = false
 $DEBUG   = false
 $SAFE    = 0
-
-RUBY_PLATFORM       = 'opal'
-RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '2.1.5'
-RUBY_ENGINE_VERSION = '0.8.1'
-RUBY_RELEASE_DATE   = '2015-10-12'

data/opal/opal.rb

@@ -1,32 +1,18 @@
-require 'corelib/runtime'
-require 'corelib/helpers'
-require 'corelib/module'
-require 'corelib/class'
-require 'corelib/basic_object'
-require 'corelib/kernel'
-require 'corelib/nil_class'
-require 'corelib/boolean'
-require 'corelib/error'
-require 'corelib/regexp'
-require 'corelib/comparable'
-require 'corelib/enumerable'
-require 'corelib/enumerator'
-require 'corelib/array'
+require 'opal/base'
+require 'opal/mini'
+
 require 'corelib/array/inheritance'
-require 'corelib/hash'
-require 'corelib/string'
 require 'corelib/string/inheritance'
-require 'corelib/match_data'
-require 'corelib/numeric'
+require 'corelib/string/encoding'
+require 'corelib/math'
 require 'corelib/complex'
 require 'corelib/rational'
-require 'corelib/proc'
-require 'corelib/method'
-require 'corelib/range'
 require 'corelib/time'
 require 'corelib/struct'
 require 'corelib/io'
 require 'corelib/main'
-require 'corelib/variables'
 require 'corelib/dir'
 require 'corelib/file'
+require 'corelib/process'
+
+require 'corelib/unsupported'

data/opal/opal/base.rb

@@ -0,0 +1,9 @@
+require 'corelib/runtime'
+require 'corelib/helpers'
+require 'corelib/module'
+require 'corelib/class'
+require 'corelib/basic_object'
+require 'corelib/kernel'
+require 'corelib/error'
+
+require 'corelib/constants'

data/opal/opal/mini.rb

@@ -0,0 +1,17 @@
+require 'opal/base'
+
+require 'corelib/nil'
+require 'corelib/boolean'
+require 'corelib/string'
+require 'corelib/comparable'
+require 'corelib/enumerable'
+require 'corelib/enumerator'
+require 'corelib/array'
+require 'corelib/hash'
+require 'corelib/number'
+require 'corelib/range'
+require 'corelib/proc'
+require 'corelib/method'
+require 'corelib/regexp'
+
+require 'corelib/variables'

data/spec/README.md

@@ -1,7 +1,7 @@
 # Opal specs overview
 
 * **rubyspecs** (file) a whitelist of RubySpec files to be ran
-* **corelib** RubySpec examples (submodule)
+* **rubyspec** RubySpec examples (submodule)
 * **stdlib** `rubysl-*` examples (submodules)
 * **filters** The list of MSpec/RubySpec examples that are either bugs or unsupported
 * **opal** opal additions/special behaviour in the runtime/corelib

data/spec/filters/bugs/array.rb

@@ -1,157 +1,59 @@
 opal_filter "Array" do
-  fails "Array#clone copies singleton methods"
-
-  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#<=> 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.[] can unpack 2 or more nested referenced array"
-
-  fails "Array#[]= sets elements in the range arguments when passed ranges"
-
-  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#& determines equivalence between elements in the sense of eql?"
-
-  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#* 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#permutation generates from a defensive copy, ignoring mutations"
-  fails "Array#permutation returns an Enumerator which works as expected even when the array was modified"
-  fails "Array#permutation truncates Float arguments"
-  fails "Array#permutation handles nested Arrays correctly"
-  fails "Array#permutation handles duplicate elements correctly"
-  fails "Array#permutation returns no permutations when the given length has no permutations"
-  fails "Array#permutation returns the empty permutation([]) when called on an empty Array"
-  fails "Array#permutation returns the empty permutation ([[]]) when the given length is 0"
-  fails "Array#permutation yields all permutations of given length to the block then returns self when called with block and argument"
-  fails "Array#permutation yields all permutations to the block then returns self when called with block but no arguments"
-  fails "Array#permutation returns an Enumerator of permutations of given length when called with an argument but no block"
-  fails "Array#permutation returns an Enumerator of all permutations when called without a block or arguments"
-
-  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#repeated_combination generates from a defensive copy, ignoring mutations"
+  fails "Array#flatten performs respond_to? and method_missing-aware checks when coercing elements to array"
+  fails "Array#flatten with a non-Array object in the Array calls #method_missing if defined"
+  fails "Array#flatten with a non-Array object in the Array calls #to_ary if not defined when #respond_to_missing? returns true"
+  fails "Array#flatten with a non-Array object in the Array does not call #to_ary if not defined when #respond_to_missing? returns false"
+  fails "Array#join raises a NoMethodError if an element does not respond to #to_str, #to_ary, or #to_s"
+  fails "Array#partition returns in the left array values for which the block evaluates to true"
+  fails "Array#permutation when no block is given returned Enumerator size with an array size greater than 0 returns the descending factorial of array size and given length"
+  fails "Array#permutation when no block is given returned Enumerator size with an array size greater than 0 returns the descending factorial of array size with array size when there's no param"
+  fails "Array#permutation when no block is given returned Enumerator size with an empty array returns 1 when the given length is 0"
+  fails "Array#permutation when no block is given returned Enumerator size with an empty array returns 1 when there's param"
+  fails "Array#pop passed a number n as an argument raises an ArgumentError if more arguments are passed" #Arity issue?
+  fails "Array#rassoc calls elem == obj on the second element of each contained array" #Spec assumes string and symbols are not equal.
+  fails "Array#rassoc does not check the last element in each contained but speficically the second" #Spec assumes string and symbols are not equal.
   fails "Array#repeated_combination accepts sizes larger than the original array"
+  fails "Array#repeated_combination generates from a defensive copy, ignoring mutations"
+  fails "Array#repeated_combination returns an enumerator when no block is provided"
+  fails "Array#repeated_combination returns self when a block is given"
+  fails "Array#repeated_combination when no block is given returned Enumerator size returns 0 when the combination_size is < 0"
+  fails "Array#repeated_combination when no block is given returned Enumerator size returns 1 when the combination_size is 0"
+  fails "Array#repeated_combination when no block is given returned Enumerator size returns the binomial coeficient between combination_size and array size + combination_size -1"
   fails "Array#repeated_combination yields a partition consisting of only singletons"
+  fails "Array#repeated_combination yields nothing for negative length and return self"
   fails "Array#repeated_combination yields nothing when the array is empty and num is non zero"
-  fails "Array#repeated_combination yields [] when length is 0"
   fails "Array#repeated_combination yields the expected repeated_combinations"
-  fails "Array#repeated_combination yields nothing for negative length and return self"
-  fails "Array#repeated_combination returns self when a block is given"
-  fails "Array#repeated_combination returns an enumerator when no block is provided"
-
-  fails "Array#repeated_permutation generates from a defensive copy, ignoring mutations"
+  fails "Array#repeated_combination yields [] when length is 0"
   fails "Array#repeated_permutation allows permutations larger than the number of elements"
+  fails "Array#repeated_permutation does not yield when called on an empty Array with a nonzero argument"
+  fails "Array#repeated_permutation generates from a defensive copy, ignoring mutations"
+  fails "Array#repeated_permutation handles duplicate elements correctly"
+  fails "Array#repeated_permutation returns an Enumerator of all repeated permutations of given length when called without a block"
   fails "Array#repeated_permutation returns an Enumerator which works as expected even when the array was modified"
   fails "Array#repeated_permutation truncates Float arguments"
-  fails "Array#repeated_permutation handles duplicate elements correctly"
-  fails "Array#repeated_permutation does not yield when called on an empty Array with a nonzero argument"
-  fails "Array#repeated_permutation yields the empty repeated_permutation ([[]]) when the given length is 0"
+  fails "Array#repeated_permutation when no block is given returned Enumerator size returns 0 when combination_size is < 0"
+  fails "Array#repeated_permutation when no block is given returned Enumerator size returns array size ** combination_size"
   fails "Array#repeated_permutation yields all repeated_permutations to the block then returns self when called with block but no arguments"
-  fails "Array#repeated_permutation returns an Enumerator of all repeated permutations of given length when called without a block"
-
-  fails "Array#rindex rechecks the array size during iteration"
-
-  fails "Array#sample calls #rand on the Object passed by the :random key in the arguments Hash"
-  fails "Array#sample calls #to_hash to convert the passed Object"
-  fails "Array#sample calls #to_int on the Object returned by #rand"
-  fails "Array#sample calls #to_int on the first argument and #to_hash on the second when passed Objects"
-  fails "Array#sample calls #to_int to convert the count when passed an Object"
-  fails "Array#sample does not return the same value if the Array has unique values"
-  fails "Array#sample ignores an Object passed for the RNG if it does not define #rand"
-  fails "Array#sample raises ArgumentError when passed a negative count"
-  fails "Array#sample raises a RangeError if the value is equal to the Array size"
-  fails "Array#sample raises a RangeError if the value is less than zero"
-  fails "Array#sample returns at most the number of elements in the Array"
-  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int calls #to_int on the Object"
-  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int raises a RangeError if the value is equal to the Array size"
-  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int raises a RangeError if the value is less than zero"
-  fails "Array#sample with options calls #rand on the Object passed by the :random key in the arguments Hash"
-  fails "Array#sample with options calls #to_hash to convert the passed Object"
-  fails "Array#sample with options calls #to_int on the first argument and #to_hash on the second when passed Objects"
-  fails "Array#sample with options ignores an Object passed for the RNG if it does not define #rand"
-  fails "Array#sample with options when the object returned by #rand is a Fixnum raises a RangeError if the value is equal to the Array size"
-  fails "Array#sample with options when the object returned by #rand is a Fixnum raises a RangeError if the value is less than zero"
-  fails "Array#sample with options when the object returned by #rand is a Fixnum uses the fixnum as index"
-
-  fails "Array#select returns a new array of elements for which block is true"
-
-  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#repeated_permutation yields the empty repeated_permutation ([[]]) when the given length is 0"
+  fails "Array#select returns a new array of elements for which block is true" #Spec assumes integer division
+  fails "Array#shift passed a number n as an argument raises an ArgumentError if more arguments are passed" #Arity issue?
   fails "Array#slice! calls to_int on range arguments"
   fails "Array#slice! calls to_int on start and length arguments"
   fails "Array#slice! does not expand array with indices out of bounds"
   fails "Array#slice! does not expand array with negative indices out of bounds"
   fails "Array#slice! removes and return elements in range"
   fails "Array#slice! removes and returns elements in end-exclusive ranges"
-
+  fails "Array#slice! returns nil if length is negative"
+  fails "Array#sort_by! completes when supplied a block that always returns the same result"
   fails "Array#sort_by! makes some modification even if finished sorting when it would break in the given block"
-  fails "Array#sort_by! returns the specified value when it would break in the given block"
-  fails "Array#sort_by! raises a RuntimeError on an empty frozen array"
   fails "Array#sort_by! raises a RuntimeError on a frozen array"
-  fails "Array#sort_by! completes when supplied a block that always returns the same result"
+  fails "Array#sort_by! raises a RuntimeError on an empty frozen array"
   fails "Array#sort_by! returns an Enumerator if not given a block"
+  fails "Array#sort_by! returns the specified value when it would break in the given block"
   fails "Array#sort_by! sorts array in place by passing each element to the given block"
-
-  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 handles nil and false like any other values"
-  fails "Array#uniq uses eql? semantics"
-  fails "Array#uniq yields items in order"
-
-  fails "Array#uniq! compares elements based on the value returned from the block"
-
-  fails "Array#hash returns the same fixnum for arrays with the same content"
-
-  fails "Array#partition returns in the left array values for which the block evaluates to true"
-
-  fails "Array#| acts as if using an intermediate hash to collect values"
-
-  # recursive arrays
+  fails "Array#sort_by! when no block is given returned Enumerator size returns the enumerable size"
   fails "Array#uniq! properly handles recursive arrays"
-  fails "Array#<=> properly handles recursive arrays"
-  fails "Array#values_at properly handles recursive arrays"
-  fails "Array#hash returns the same hash for equal recursive arrays through hashes"
-
-  fails "Array#first raises a RangeError when count is a Bignum"
-  fails "Array#hash calls to_int on result of calling hash on each element"
+  fails "Array#zip fills nil when the given enumereator is shorter than self"
+  fails "Array#zip stops at own size when given an infinite enumerator"
+  fails "Array.[] can unpack 2 or more nested referenced array"
 end