opal 0.10.0.beta2 → 0.10.0.beta3

data/opal/corelib/proc.rb

@@ -62,11 +62,14 @@ class Proc < `Function`
     `!!self.$$is_lambda`
   end
 
-  # FIXME: this should support the various splats and optional arguments
   def arity
-    `if (self.$$is_curried) { return -1; }`
-    `if (self.$$arity) { return self.$$arity }`
-    `self.length`
+    %x{
+      if (self.$$is_curried) {
+        return -1;
+      } else {
+        return self.$$arity;
+      }
+    }
   end
 
   def source_location
@@ -80,8 +83,32 @@ class Proc < `Function`
   end
 
   def parameters
-    `if (self.$$is_curried) { return #{[[:rest]]}; }`
-    nil
+    %x{
+      if (self.$$is_curried) {
+        return #{[[:rest]]};
+      } else if (self.$$parameters) {
+        if (self.$$is_lambda) {
+          return self.$$parameters;
+        } else {
+          var result = [], i, length;
+
+          for (i = 0, length = self.$$parameters.length; i < length; i++) {
+            var parameter = self.$$parameters[i];
+
+            if (parameter[0] === 'req') {
+              // required arguments always have name
+              parameter = ['opt', parameter[1]];
+            }
+
+            result.push(parameter);
+          }
+
+          return result;
+        }
+      } else {
+        return [];
+      }
+    }
   end
 
   def curry(arity = undefined)

data/opal/corelib/range.rb

@@ -134,4 +134,10 @@ class Range
   end
 
   alias inspect to_s
+
+  def marshal_load(args)
+    @begin = args[:begin]
+    @end = args[:end]
+    @exclude = args[:excl]
+  end
 end

data/opal/corelib/regexp.rb

@@ -80,7 +80,7 @@ class Regexp < `RegExp`
 
         regexp = #{Opal.coerce_to!(regexp, String, :to_str)};
 
-        if (regexp.charAt(regexp.length - 1) === '\\') {
+        if (regexp.charAt(regexp.length - 1) === '\\' && regexp.charAt(regexp.length - 2) !== '\\') {
           #{raise RegexpError, "too short escape sequence: /#{regexp}/"}
         }
 
@@ -202,6 +202,10 @@ class Regexp < `RegExp`
   end
 
   alias to_s source
+
+  def self._load(args)
+    self.new(*args)
+  end
 end
 
 class MatchData

data/opal/corelib/runtime.js

@@ -327,6 +327,9 @@
     // Every class gets its own constant scope, inherited from current scope
     Opal.create_scope(base.$$scope, klass, name);
 
+    // Name new class directly onto current scope (Opal.Foo.Baz = klass)
+    base[name] = klass;
+
     if (bridged) {
       Opal.bridge(klass, alloc);
     }
@@ -1029,12 +1032,7 @@
       }
     }
     else {
-      if (obj.$$is_class || obj.$$is_module) {
-        dispatcher = obj.$$super;
-      }
-      else {
-        dispatcher = Opal.find_obj_super_dispatcher(obj, jsid, current_func);
-      }
+      dispatcher = Opal.find_obj_super_dispatcher(obj, jsid, current_func);
     }
 
     dispatcher = dispatcher['$' + jsid];
@@ -1068,24 +1066,50 @@
 
   Opal.find_obj_super_dispatcher = function(obj, jsid, current_func) {
     var klass = obj.$$meta || obj.$$class;
+
+    // first we need to find the class/module current_func is located on
+    klass = Opal.find_owning_class(klass, current_func);
+
+    if (!klass) {
+      throw new Error("could not find current class for super()");
+    }
+
     jsid = '$' + jsid;
+    return Opal.find_super_func(klass, jsid, current_func);
+  };
+
+  Opal.find_owning_class = function(klass, current_func) {
+    var owner = current_func.$$owner;
 
-    // first we need to find the class/module current_func is defined/donated on
     while (klass) {
-      // when a module has been included in a class, look for that
-      if ((klass.$$iclass && klass.$$module === current_func.$$owner) || klass === current_func.$$owner) {
+      // repeating for readability
+
+      if (klass.$$iclass && klass.$$module === current_func.$$donated) {
+        // this klass was the last one the module donated to
+        // case is also hit with multiple module includes
+        break;
+      }
+      else if (klass.$$iclass && klass.$$module === owner) {
+        // module has donated to other classes but klass isn't one of those
+        break;
+      }
+      else if (owner.$$is_singleton && klass === owner.$$singleton_of.$$class) {
+        // cases like stdlib `Singleton::included` that use a singleton of a singleton
+        break;
+      }
+      else if (klass === owner) {
+        // no modules, pure class inheritance
         break;
       }
 
       klass = klass.$$parent;
     }
 
-    // if we arent in a class, we couldnt find current?
-    if (!klass) {
-      throw new Error("could not find current class for super()");
-    }
+    return klass;
+  };
 
-    klass = klass.$$parent;
+  Opal.find_super_func = function(owning_klass, jsid, current_func) {
+    var klass = owning_klass.$$parent;
 
     // now we can find the super
     while (klass) {
@@ -1132,7 +1156,14 @@
       throw Opal.LocalJumpError.$new("no block given");
     }
 
-    if (block.length > 1 && arg.$$is_array) {
+    var has_mlhs = block.$$has_top_level_mlhs_arg,
+        has_trailing_comma = block.$$has_trailing_comma_in_args;
+
+    if (block.length > 1 || ((has_mlhs || has_trailing_comma) && block.length === 1)) {
+      arg = Opal.to_ary(arg);
+    }
+
+    if ((block.length > 1 || (has_trailing_comma && block.length === 1)) && arg.$$is_array) {
       return block.apply(null, arg);
     }
     else {
@@ -1204,6 +1235,27 @@
     return false;
   };
 
+  // Helpers for extracting kwsplats
+  // Used for: { **h }
+  Opal.to_hash = function(value) {
+    if (value.$$is_hash) {
+      return value;
+    }
+    else if (value['$respond_to?']('to_hash', true)) {
+      var hash = value.$to_hash();
+      if (hash.$$is_hash) {
+        return hash;
+      }
+      else {
+        throw Opal.TypeError.$new("Can't convert " + value.$$class +
+          " to Hash (" + value.$$class + "#to_hash gives " + hash.$$class + ")");
+      }
+    }
+    else {
+      throw Opal.TypeError.$new("no implicit conversion of " + value.$$class + " into Hash");
+    }
+  };
+
   // Helpers for implementing multiple assignment
   // Our code for extracting the values and assigning them only works if the
   // return value is a JS array.
@@ -1371,8 +1423,8 @@
   // a method is defined inside an `instance_eval` block.
   //
   // @param obj  [Object, Class] the actual obj to define method for
-  // @param jsid [String] the javascript friendly method name (e.g. '$foo')
-  // @param body [JS.Function] the literal javascript function used as method
+  // @param jsid [String] the JavaScript friendly method name (e.g. '$foo')
+  // @param body [JS.Function] the literal JavaScript function used as method
   // @return [null]
   //
   Opal.defn = function(obj, jsid, body) {

data/opal/corelib/string.rb

@@ -1684,6 +1684,14 @@ class String < `String`
       return null;
     }
   }
+
+  def instance_variables
+    []
+  end
+
+  def self._load(*args)
+    self.new(*args)
+  end
 end
 
 Symbol = String

data/opal/corelib/string/inheritance.rb

@@ -116,4 +116,8 @@ class String::Wrapper
   def %(data)
     @literal % data
   end
+
+  def instance_variables
+    super - ['@literal']
+  end
 end

data/opal/corelib/struct.rb

@@ -260,4 +260,9 @@ class Struct
       return result;
     }
   end
+
+  def self._load(args)
+    attributes = args.values_at(*members)
+    self.new(*attributes)
+  end
 end

data/opal/corelib/unsupported.rb

@@ -133,24 +133,6 @@ module Kernel
   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{

data/opal/opal/full.rb

@@ -0,0 +1 @@
+require 'corelib/marshal'

data/spec/filters/bugs/basicobject.rb

@@ -3,13 +3,11 @@ opal_filter "BasicObject" do
   fails "BasicObject does not define built-in constants (according to defined?)"
   fails "BasicObject raises NameError when referencing built-in constants"
   fails "BasicObject raises NoMethodError for nonexistent methods after #method_missing is removed"
-  fails "BasicObject#__send__ has a negative arity"
   fails "BasicObject#initialize does not accept arguments"
   fails "BasicObject#instance_eval raises a TypeError when defining methods on an immediate"
   fails "BasicObject#instance_eval raises a TypeError when defining methods on numerics"
   fails "BasicObject#instance_eval sets class variables in the receiver"
   fails "BasicObject#instance_exec binds the block's binding self to the receiver"
-  fails "BasicObject#instance_exec has an arity of -1"
   fails "BasicObject#instance_exec raises a LocalJumpError unless given a block"
   fails "BasicObject#instance_exec raises a TypeError when defining methods on an immediate"
   fails "BasicObject#instance_exec raises a TypeError when defining methods on numerics"

data/spec/filters/bugs/compiler_opal.rb

@@ -0,0 +1,5 @@
+opal_filter "compiler (opal)" do
+  fails 'Opal::Compiler should compile undef calls'
+  fails 'Opal::Compiler method names when function name is reserved generates a valid named function for method'
+  fails 'Opal::Compiler pre-processing require-ish methods #require_tree parses and resolve #require argument'
+end

data/spec/filters/bugs/enumerable.rb

@@ -33,6 +33,7 @@ opal_filter "Enumerable" do
   fails "Enumerable#slice_when when given a block returns an enumerator"
   fails "Enumerable#slice_when when given a block splits chunks between adjacent elements i and j where the block returns true"
   fails "Enumerable#slice_when when not given a block raises an ArgumentError"
+  fails "Enumerable#slice_when when an iterator method yields more than one value processes all yielded values"
   fails "Enumerable#sort_by returns an array of elements when a block is supplied and #map returns an enumerable"
   fails "Enumerable#take_while calls the block with initial args when yielded with multiple arguments"
   fails "Enumerable#to_h calls #to_ary on contents"

data/spec/filters/bugs/enumerator.rb

@@ -1,5 +1,4 @@
 opal_filter "Enumerator" do
-  fails "Enumerator#each requires multiple arguments"
   fails "Enumerator#each_with_index raises an ArgumentError if passed extra arguments"
   fails "Enumerator#each_with_index returns the object being enumerated when given a block"
   fails "Enumerator#enum_for exposes multi-arg yields as an array"
@@ -18,7 +17,6 @@ opal_filter "Enumerator" do
   fails "Enumerator#initialize sets size to the given size if the given size is a Fixnum"
   fails "Enumerator#initialize sets size to the given size if the given size is a Proc"
   fails "Enumerator#initialize sets size to the given size if the given size is Float::INFINITY"
-  fails "Enumerator#inject requires multiple arguments"
   fails "Enumerator#next_values advances the position of the current element"
   fails "Enumerator#next_values advances the position of the enumerator each time when called multiple times"
   fails "Enumerator#next_values raises StopIteration if called on a finished enumerator"

data/spec/filters/bugs/exception.rb

@@ -53,7 +53,6 @@ opal_filter "Exception" do
   fails "SystemCallError.new accepts single Fixnum argument as errno"
   fails "SystemCallError.new constructs the appropriate Errno class"
   fails "SystemCallError.new requires at least one argument"
-  fails "SystemCallError.new returns an arity of -1 for the initialize method"
   fails "SystemStackError is a subclass of Exception"
   fails "rescueing SignalException raises a SignalException when sent a signal"
 end

data/spec/filters/bugs/kernel.rb

@@ -47,7 +47,6 @@ opal_filter "Kernel" do
   fails "Kernel#extend on frozen instance raises a RuntimeError"
   fails "Kernel#extend on frozen instance raises an ArgumentError when no arguments given"
   fails "Kernel#extend raises an ArgumentError when no arguments given"
-  fails "Kernel#extend requires multiple arguments"
   fails "Kernel#freeze causes instance_variable_set to raise RuntimeError"
   fails "Kernel#freeze causes mutative calls to raise RuntimeError"
   fails "Kernel#freeze on a Float has no effect since it is already frozen"
@@ -118,7 +117,6 @@ opal_filter "Kernel" do
   fails "Kernel#public_methods returns a list of the names of publicly accessible methods in the object"
   fails "Kernel#public_methods when passed false returns a list of public methods in without its ancestors"
   fails "Kernel#public_methods when passed nil returns a list of public methods in without its ancestors"
-  fails "Kernel#public_send has a negative arity"
   fails "Kernel#public_send raises a NoMethodError if the method is protected"
   fails "Kernel#public_send raises a NoMethodError if the named method is an alias of a private method"
   fails "Kernel#public_send raises a NoMethodError if the named method is an alias of a protected method"
@@ -149,7 +147,6 @@ opal_filter "Kernel" do
   fails "Kernel#respond_to_missing? isn't called when obj responds to the given protected method, include_private = true"
   fails "Kernel#respond_to_missing? isn't called when obj responds to the given public method"
   fails "Kernel#respond_to_missing? isn't called when obj responds to the given public method, include_private = true"
-  fails "Kernel#send has a negative arity"
   fails "Kernel#singleton_class raises TypeError for Fixnum"
   fails "Kernel#singleton_class raises TypeError for Symbol"
   fails "Kernel#singleton_methods when not passed an argument does not return any included methods for a class including a module"
@@ -234,7 +231,6 @@ opal_filter "Kernel" do
   fails "Kernel#singleton_methods when passed true returns the names of singleton methods for an object extented with a module"
   fails "Kernel#singleton_methods when passed true returns the names of singleton methods for an object extented with two modules"
   fails "Kernel#singleton_methods when passed true returns the names of singleton methods for an object"
-  fails "Kernel#warn requires multiple arguments"
   fails "Kernel.Complex() when passed Numerics n1 and n2 and at least one responds to #real? with false returns n1 + n2 * Complex(0, 1)"
   fails "Kernel.Complex() when passed [Complex, Complex] returns a new Complex number based on the two given numbers"
   fails "Kernel.Complex() when passed [Complex] returns the passed Complex number"
@@ -288,7 +284,6 @@ opal_filter "Kernel" do
   fails "Kernel.loop is a private method"
   fails "Kernel.loop rescues StopIteration"
   fails "Kernel.loop rescues StopIteration's subclasses"
-  fails "Kernel.loop returns an enumerator if no block given"
   fails "Kernel.loop when no block is given returned Enumerator size returns Float::INFINITY"
   fails "Kernel.printf calls write on the first argument when it is not a string"
   fails "Kernel.printf writes to stdout when a string is the first argument"

data/spec/filters/bugs/language.rb

@@ -18,6 +18,7 @@ opal_filter "language" do
   fails "A class variable defined in a module is not defined in these classes"
   fails "A class variable defined in a module is only updated in the module a method defined in the module is used"
   fails "A class variable defined in a module is updated in the class when a Method defined in the class is used"
+  fails "A class variable definition is created in a module if any of the parents do not define it"
   fails "A constant on a metaclass appears in the metaclass constant list"
   fails "A constant on a metaclass cannot be accessed via object::CONST"
   fails "A constant on a metaclass does not appear in the object's class constant list"
@@ -161,7 +162,6 @@ opal_filter "language" do
   fails "The super keyword calls the correct method when the method visibility is modified"
   fails "The super keyword passes along modified rest args when they were originally empty"
   fails "The super keyword passes along modified rest args when they weren't originally empty"
-  fails "The super keyword sees the included version of a module a method is alias from"
   fails "The super keyword uses given block even if arguments are passed explicitly"
   fails "The super keyword when using keyword arguments passes any given keyword arguments including optional and required ones to the parent"
   fails "The super keyword without explicit arguments passes arguments and rest arguments including any modifications"
@@ -239,24 +239,6 @@ opal_filter "language" do
   fails "A block yielded a single Array does not treat hashes with string keys as keyword arguments"
   fails "A block yielded a single Array assigns the last element to a non-keyword argument if #to_hash returns nil"
   fails "A block yielded a single Array raises a TypeError if #to_hash does not return a Hash"
-  fails "A block yielded a single Object calls #to_ary on the object when taking multiple arguments"
-  fails "A block yielded a single Object receives the object if #to_ary returns nil"
-  fails "A block yielded a single Object raises a TypeError if #to_ary does not return an Array"
-  fails "A block allows for a leading space before the arguments"
-  fails "A block taking |a, b| arguments calls #to_ary to convert a single yielded object to an Array"
-  fails "A block taking |a, b| arguments raises a TypeError if #to_ary does not return an Array"
-  fails "A block taking |a, b| arguments raises the original exception if #to_ary raises an exception"
-  fails "A block taking |a, *b| arguments calls #to_ary to convert a single yielded object to an Array"
-  fails "A block taking |a, *b| arguments raises a TypeError if #to_ary does not return an Array"
-  fails "A block taking |a, | arguments assigns nil to the argument when passed an empty Array"
-  fails "A block taking |a, | arguments assigns the argument the first element of the Array when passed a single Array"
-  fails "A block taking |a, | arguments calls #to_ary to convert a single yielded object to an Array"
-  fails "A block taking |a, | arguments does not call #to_ary if the single yielded object is an Array"
-  fails "A block taking |a, | arguments raises a TypeError if #to_ary does not return an Array"
-  fails "A block taking |(a, b)| arguments calls #to_ary to convert a single yielded object to an Array"
-  fails "A block taking |(a, b)| arguments raises a TypeError if #to_ary does not return an Array"
-  fails "A block taking |(a, b), c| arguments calls #to_ary to convert a single yielded object to an Array"
-  fails "A block taking |(a, b), c| arguments raises a TypeError if #to_ary does not return an Array"
   fails "A block taking identically-named arguments raises a SyntaxError for standard arguments"
   fails "Block-local variables can not have the same name as one of the standard parameters"
   fails "Block-local variables override shadowed variables from the outer scope"
@@ -288,15 +270,7 @@ opal_filter "language" do
   fails "A Proc taking |(a, b)| arguments calls #to_ary to convert a single passed object to an Array"
   fails "A Proc taking |(a, b)| arguments calls #to_ary to convert a single passed object to an Array"
   fails "A Proc taking |(a, b)| arguments raises a TypeError if #to_ary does not return an Array"
-  fails "A singleton method definition can be declared for a local variable"
-  fails "A singleton method definition can be declared for an instance variable"
   fails "A singleton method definition can be declared for a global variable"
-  fails "A singleton method definition can be declared for a class variable"
-  fails "A singleton method defined with extreme default arguments may use a method definition as a default"
-  fails "A singleton method defined with extreme default arguments may use an fcall as a default"
-  fails "A singleton method defined with extreme default arguments evaluates the defaults in the singleton scope"
-  fails "A singleton method defined with extreme default arguments may use preceding arguments as defaults"
-  fails "A singleton method defined with extreme default arguments may use a lambda as a default"
   fails "A nested method definition creates an instance method when evaluated in an instance method"
   fails "A nested method definition creates a class method when evaluated in a class method"
   fails "A method defined with extreme default arguments may use an fcall as a default" # fails on phantomjs
@@ -306,4 +280,10 @@ opal_filter "language" do
   fails "An instance method with a default argument shadows an existing method with the same name as the local"
   fails "A nested method definition creates a method in the surrounding context when evaluated in a def expr.method"
   fails "The def keyword within a closure looks outside the closure for the visibility"
+  fails "Invoking a method allows []= with *args in the [] expanded to individual arguments"
+  fails "Invoking a method allows []= with multiple *args and does not unwrap the last splat"
+  fails "Invoking a method allows []= with multiple *args"
+  fails "Invoking a method allows []= with a *args and multiple rhs args"
+  fails "Invoking a method does not expand final array arguments after a splat expansion"
+  fails "Invoking a private getter method does not permit self as a receiver"
 end

data/spec/filters/bugs/marshal.rb

@@ -0,0 +1,43 @@
+opal_filter "Marshal" do
+  # Marshal.load
+  fails "Marshal.load loads an array containing objects having _dump method, and with proc"
+  fails "Marshal.load loads an array containing objects having marshal_dump method, and with proc"
+  fails "Marshal.load assigns classes to nested subclasses of Array correctly"
+  fails "Marshal.load loads a _dump object"
+  fails "Marshal.load loads a _dump object extended"
+  fails "Marshal.load when called with a proc returns the value of the proc"
+  fails "Marshal.load when called with a proc calls the proc for recursively visited data"
+  fails "Marshal.load when called with a proc loads an Array with proc"
+  fails "Marshal.load when called on objects with custom _dump methods does not set instance variables of an object with user-defined _dump/_load"
+  fails "Marshal.load when called on objects with custom _dump methods that return an immediate value loads an array containing an instance of the object, followed by multiple instances of another object"
+  fails "Marshal.load when called on objects with custom _dump methods that return an immediate value loads any structure with multiple references to the same object, followed by multiple instances of another object"
+  fails "Marshal.load when called on objects with custom _dump methods that return an immediate value loads an array containing references to multiple instances of the object, followed by multiple instances of another object"
+  fails "Marshal.load for an Array loads an extended Array object containing a user-marshaled object"
+  fails "Marshal.load for a String loads a String subclass with custom constructor"
+  fails "Marshal.load for a Struct does not call initialize on the unmarshaled struct"
+  fails "Marshal.load for an Exception loads a marshalled exception with no message"
+  fails "Marshal.load for an Exception loads a marshalled exception with a message"
+  fails "Marshal.load for an Exception loads a marshalled exception with a backtrace"
+  fails "Marshal.load for a user Class raises ArgumentError if the object from an 'o' stream is not dumpable as 'o' type user class"
+  fails "Marshal.load for a user Class loads an object having ivar"
+  fails "Marshal.load for a user Class that extends a core type other than Object or BasicObject raises ArgumentError if the resulting class does not extend the same type"
+  fails "Marshal.load for a Regexp loads a extended_user_regexp having ivar"
+  fails "Marshal.load for a Hash loads an extended_user_hash with a parameter to initialize"
+  fails "Marshal.load for a Time loads"
+  fails "Marshal.load for a Time loads nanoseconds"
+  fails "Marshal.load for a Module loads an old module"
+  fails "Marshal.load when a class does not exist in the namespace raises an ArgumentError" # an issue with constant resolving, e.g. String::Array
+
+  # Marshal.dump
+  fails "Marshal.dump ignores the recursion limit if the limit is negative" # no support yet
+  fails "Marshal.dump with an object responding to #_dump dumps the object returned by #marshal_dump"
+  fails "Marshal.dump with a Time dumps the zone and the offset"
+  fails "Marshal.dump with a Time dumps the zone and the offset"
+  fails "Marshal.dump with a Regexp dumps a Regexp with instance variables" # //.source.should == ''
+  fails "Marshal.dump with a Regexp dumps a Regexp subclass" # requires Class.new(Regexp).new("").class != Regexp
+  fails "Marshal.dump with an Object dumps a BasicObject subclass if it defines respond_to?"
+  fails "Marshal.dump with a Time dumps the zone, but not the offset if zone is UTC"
+  fails "Marshal.dump with an Exception dumps an empty Exception"
+  fails "Marshal.dump with an Exception dumps the message for the exception"
+  fails "Marshal.dump with an Exception contains the filename in the backtrace"
+end