opal 0.9.0.rc1 → 0.9.0

data/opal/corelib/runtime.js

@@ -114,20 +114,24 @@
   // base. Constants are looked up through their parents, so the base
   // scope will be the outer scope of the new klass.
   //
-  Opal.create_scope = function(base, klass, id) {
+  // @param base_scope [$$scope] the scope in which the new scope should be created
+  // @param klass      [Class]
+  // @param id         [String, null] the name of the newly created scope
+  //
+  Opal.create_scope = function(base_scope, klass, id) {
     var const_alloc = function() {};
-    var const_scope = const_alloc.prototype = new base.constructor();
+    var const_scope = const_alloc.prototype = new base_scope.constructor();
 
     klass.$$scope       = const_scope;
-    klass.$$base_module = base.base;
+    klass.$$base_module = base_scope.base;
 
     const_scope.base        = klass;
     const_scope.constructor = const_alloc;
     const_scope.constants   = [];
 
     if (id) {
-      Opal.cdecl(base, id, klass);
-      const_alloc.displayName = id+"_alloc";
+      Opal.cdecl(base_scope, id, klass);
+      const_alloc.displayName = id+"_scope_alloc";
     }
   }
 
@@ -149,11 +153,12 @@
   // If `base` is an object (not a class/module), we simple get its class and
   // use that as the base instead.
   //
-  // @param [Object] base where the class is being created
-  // @param [Class] superklass superclass of the new class (may be null)
-  // @param [String] id the name of the class to be created
-  // @param [Function] constructor function to use as constructor
-  // @return [Class] new or existing ruby class
+  // @param base        [Object] where the class is being created
+  // @param superklass  [Class,null] superclass of the new class (may be null)
+  // @param id          [String] the name of the class to be created
+  // @param constructor [Function] function to use as constructor
+  //
+  // @return new [Class]  or existing ruby class
   //
   Opal.klass = function(base, superklass, id, constructor) {
     var klass, bridged, alloc;
@@ -341,9 +346,9 @@
   // Otherwise, a new module is created in the base with the given name, and that
   // new instance is returned back (to be referenced at runtime).
   //
-  // @param [RubyModule or Class] base class or module this definition is inside
-  // @param [String] id the name of the new (or existing) module
-  // @return [RubyModule]
+  // @param  base [Module, Class] class or module this definition is inside
+  // @param  id [String] the name of the new (or existing) module
+  // @return [Module]
   //
   Opal.module = function(base, id) {
     var module;
@@ -696,7 +701,17 @@
   }
 
 
-  // constant assign
+  // Constant assignment, see also `Opal.cdecl`
+  //
+  // @param base_module [Module, Class] the constant namespace
+  // @param name        [String] the name of the constant
+  // @param value       [Object] the value of the constant
+  //
+  // @example Assigning a namespaced constant
+  //   self::FOO = 'bar'
+  //
+  // @example Assigning with Module#const_set
+  //   Foo.const_set :BAR, 123
   //
   Opal.casgn = function(base_module, name, value) {
     function update(klass, name) {
@@ -714,7 +729,8 @@
     var scope = base_module.$$scope;
 
     if (value.$$is_class || value.$$is_module) {
-      // only checking _Object prevents setting a const on an anonymous class that has a superclass that's not Object
+      // Only checking _Object prevents setting a const on an anonymous class
+      // that has a superclass that's not Object
       if (value.$$is_class || value.$$base_module === _Object) {
         value.$$base_module = base_module;
       }

data/opal/corelib/string.rb

@@ -1575,7 +1575,7 @@ class String < `String`
     return enum_for :upto, stop, excl unless block_given?
     stop = Opal.coerce_to(stop, String, :to_str)
     %x{
-      var a, b, s = self.toString();
+      var a, b, s = self.toString(), value;
 
       if (s.length === 1 && stop.length === 1) {
 
@@ -1586,7 +1586,10 @@ class String < `String`
           if (excl && a === b) {
             break;
           }
-          block(String.fromCharCode(a));
+
+          value = block(String.fromCharCode(a));
+          if (value === $breaker) { return $breaker.$v; }
+
           a += 1;
         }
 
@@ -1599,7 +1602,10 @@ class String < `String`
           if (excl && a === b) {
             break;
           }
-          block(a.toString());
+
+          value = block(a.toString());
+          if (value === $breaker) { return $breaker.$v; }
+
           a += 1;
         }
 
@@ -1609,7 +1615,10 @@ class String < `String`
           if (excl && s === stop) {
             break;
           }
-          block(s);
+
+          value = block(s);
+          if (value === $breaker) { return $breaker.$v; }
+
           s = #{`s`.succ};
         }
 

data/spec/filters/bugs/language.rb

@@ -6,10 +6,10 @@ opal_filter "language" do
   fails "A class definition extending an object (sclass) can use return to cause the enclosing method to return"
   fails "A class definition extending an object (sclass) raises a TypeError when trying to extend numbers"
   fails "A class definition has no class variables"
-  fails "A class definition raises a TypeError if inheriting from a metaclass"
   fails "A class definition raises TypeError if any constant qualifying the class is not a Module"
   fails "A class definition raises TypeError if constant given as class name exists and is not a Module"
   fails "A class definition raises TypeError if the constant qualifying the class is nil"
+  fails "A class definition raises a TypeError if inheriting from a metaclass"
   fails "A class variable defined in a module can be accessed from classes that extend the module"
   fails "A class variable defined in a module can be accessed from modules that extend the module"
   fails "A class variable defined in a module can be accessed inside the class using the module methods"
@@ -31,6 +31,52 @@ opal_filter "language" do
   fails "A constant on a singleton class is not defined on the object's class"
   fails "A constant on a singleton class is not preserved when the object is duped"
   fails "A constant on a singleton class raises a NameError for anonymous_module::CONST"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda do |(a, b, *c, d), (*e, f, g), (*h)|\n      [a, b, c, d, e, f, g, h]\n    end"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda do |a, (b, (c, *d, (e, (*f)), g), (h, (i, j)))|\n      [a, b, c, d, e, f, g, h, i, j]\n    end"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda do |a, b=1, *c, (*d, (e)), f: 2, g:, h:, **k, &l|\n      [a, b, c, d, e, f, g, h, k, l]\n    end"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda do |a, b=1, *c, d, e:, f: 2, g:, **k, &l|\n      [a, b, c, d, e, f, g, k, l]\n    end"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda do |a: (@a = -> (a: 1) { a }), b:|\n      [a, b]\n    end"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |(*a, b)| [a, b] }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |(a)| a }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |**k| k }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |**|  }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |*, &b| b }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |*, **k| k }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |*| }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a, | a }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a: 1, b: 2| [a, b] }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a: 1, b:| [a, b] }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a: 1| a }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a:, b: 1| [a, b] }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a:, b:| [a, b] }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    @a = lambda { |a:| a }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    def m(*a) yield(*a) end\n    @a = lambda { |a| a }"
+  fails "A lambda expression 'lambda { ... }' assigns variables from parameters for definition \n    def m(a) yield a end\n    def m2() yield end\n    @a = lambda { |a, | a }"
+  fails "A lambda expression 'lambda { ... }' requires a block"
+  fails "A lambda expression 'lambda { ... }' with an implicit block can be created"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> ((*a, b)) { [a, b] }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> ((a)) { a }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> ((a, b, *c, d), (*e, f, g), (*h)) do\n      [a, b, c, d, e, f, g, h]\n    end"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (*) { }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (**) {  }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (**k) { k }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (*, &b) { b }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (*, **k) { k }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a, (b, (c, *d, (e, (*f)), g), (h, (i, j)))) do\n      [a, b, c, d, e, f, g, h, i, j]\n    end"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a, b) { [a, b] }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a, b=1, *c, (*d, (e)), f: 2, g:, h:, **k, &l) do\n      [a, b, c, d, e, f, g, h, k, l]\n    end"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a: 1) { a }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a: 1, b: 2) { [a, b] }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a: 1, b:) { [a, b] }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a: @a = -> (a: 1) { a }, b:) do\n      [a, b]\n    end"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a:) { a }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a:, b: 1) { [a, b] }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a:, b:) { [a, b] }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> (a={}) { a }"
+  fails "A lambda literal -> () { } assigns variables from parameters for definition \n    @a = -> a, b=1, *c, d, e:, f: 2, g:, **k, &l do\n      [a, b, c, d, e, f, g, k, l]\n    end"
+  fails "A lambda literal -> () { } assigns variables from parameters with circular optional argument reference shadows an existing local with the same name as the argument"
+  fails "A lambda literal -> () { } assigns variables from parameters with circular optional argument reference shadows an existing method with the same name as the argument"
+  fails "A lambda literal -> () { } returns a Proc object when used in a BasicObject method"
   fails "A method call evaluates block pass after arguments"
   fails "A number literal can be a binary literal with trailing 'i' to represent a Complex"
   fails "A number literal can be a binary literal with trailing 'r' to represent a Rational"
@@ -46,8 +92,8 @@ opal_filter "language" do
   fails "A singleton class for BasicObject has Class as it's superclass"
   fails "A singleton class for BasicObject has the proper level of superclass for Class"
   fails "A singleton class inherits from Class for classes"
-  fails "A singleton class is a subclass of a superclass's singleton class"
   fails "A singleton class is a subclass of Class's singleton class"
+  fails "A singleton class is a subclass of a superclass's singleton class"
   fails "A singleton class is a subclass of the same level of Class's singleton class"
   fails "A singleton class is a subclass of the same level of superclass's singleton class"
   fails "A singleton class raises a TypeError for Fixnum's"
@@ -55,31 +101,45 @@ opal_filter "language" do
   fails "An ensure block inside a begin block is executed even when a symbol is thrown in it's corresponding begin block"
   fails "Assigning an anonymous module to a constant sets the name of contained modules when assigning a toplevel anonymous module"
   fails "Assigning an anonymous module to a constant sets the name of the module"
-  fails "calling methods on the metaclass calls a method defined on the metaclass of the metaclass"
   fails "Class methods of a singleton class for a class include class methods of Class"
   fails "Class methods of a singleton class for a class include instance methods of the singleton class of Class"
   fails "Class methods of a singleton class for a singleton class include class methods of the singleton class of Class"
   fails "Instance methods of a singleton class for a singleton class includes instance methods of the singleton class of Class"
   fails "Instantiating a singleton class raises a TypeError when allocate is called"
   fails "Instantiating a singleton class raises a TypeError when new is called"
-  fails "not() returns false if the argument is true"
-  fails "not() returns true if the argument is false"
-  fails "not() returns true if the argument is nil"
+  fails "Literal Regexps caches the Regexp object"
+  fails "Literal Regexps disallows alphabets as non-paired delimiter with %r"
+  fails "Literal Regexps disallows first part of paired delimiters to be used as non-paired delimiters"
+  fails "Literal Regexps disallows spaces after %r and delimiter"
+  fails "Literal Regexps matches against $_ (last input) in a conditional if no explicit matchee provided"
+  fails "Literal Regexps supports (?# )"
+  fails "Literal Regexps supports (?<! ) (negative lookbehind)"
+  fails "Literal Regexps supports (?<= ) (positive lookbehind)"
+  fails "Literal Regexps supports (?> ) (embedded subexpression)"
+  fails "Literal Regexps supports \\g (named backreference)"
+  fails "Literal Regexps supports character class composition"
+  fails "Literal Regexps supports non-paired delimiters delimiters with %r"
+  fails "Literal Regexps supports possessive quantifiers"
+  fails "Literal Regexps throws SyntaxError for malformed literals"
   fails "Operators * / % are left-associative"
-  fails "self in a metaclass body (class << obj) raises a TypeError for numbers"
-  fails "self in a metaclass body (class << obj) raises a TypeError for symbols"
+  fails "Reopening a class adds new methods to subclasses"
+  fails "The =~ operator with named captures on syntax of /regexp/ =~ string_variable sets local variables by the captured pairs"
+  fails "The =~ operator with named captures on syntax of regexp_variable =~ string_variable does not set local variables"
+  fails "The =~ operator with named captures on syntax of string_variable =~ /regexp/ does not set local variables"
+  fails "The =~ operator with named captures on the method calling does not set local variables"
+  fails "The BEGIN keyword accesses variables outside the eval scope"
+  fails "The BEGIN keyword must appear in a top-level context"
+  fails "The BEGIN keyword runs first in a given code unit"
+  fails "The BEGIN keyword runs in a shared scope"
+  fails "The BEGIN keyword runs multiple begins in FIFO order"
   fails "The __FILE__ pseudo-variable equals the absolute path of a file loaded by a relative path" # we can't clear $LOADED_FEATURES, should be treated as readonly
   fails "The __FILE__ pseudo-variable equals the absolute path of a file loaded by an absolute path" # we can't clear $LOADED_FEATURES, should be treated as readonly
+  fails "The __LINE__ pseudo-variable equals the line number of the text in a loaded file"
   fails "The alias keyword is not allowed against Fixnum or String instances"
   fails "The alias keyword on top level defines the alias on Object"
   fails "The alias keyword operates on methods defined via attr, attr_reader, and attr_accessor"
   fails "The alias keyword operates on methods with splat arguments defined in a superclass using text block for class eval"
   fails "The alias keyword operates on the object's metaclass when used in instance_eval"
-  fails "The BEGIN keyword accesses variables outside the eval scope"
-  fails "The BEGIN keyword must appear in a top-level context"
-  fails "The BEGIN keyword runs first in a given code unit"
-  fails "The BEGIN keyword runs in a shared scope"
-  fails "The BEGIN keyword runs multiple begins in FIFO order"
   fails "The defined? keyword for a scoped constant does not call .const_missing if the constant is not defined"
   fails "The defined? keyword for a scoped constant returns nil when a constant is defined on top-level but not on the module"
   fails "The defined? keyword for a scoped constant returns nil when an undefined constant is scoped to a defined constant"
@@ -89,8 +149,8 @@ opal_filter "language" do
   fails "The defined? keyword for a simple constant returns 'constant' when the constant is defined"
   fails "The defined? keyword for a simple constant returns nil when the constant is not defined"
   fails "The defined? keyword for a top-level scoped constant returns nil when an undefined constant is scoped to a defined constant"
-  fails "The defined? keyword for an expression returns nil for an expression with !~ and an undefined method"
   fails "The defined? keyword for an expression returns nil for an expression with != and an undefined method"
+  fails "The defined? keyword for an expression returns nil for an expression with !~ and an undefined method"
   fails "The defined? keyword for an expression returns nil for an expression with == and an undefined method"
   fails "The defined? keyword for an expression with logical connectives does not propagate an exception raised by a method in a 'not' expression"
   fails "The defined? keyword for an expression with logical connectives returns nil for an expression with '!' and an undefined method"
@@ -151,8 +211,8 @@ opal_filter "language" do
   fails "The super keyword raises an error error when super method does not exist"
   fails "The super keyword uses given block even if arguments are passed explicitly"
   fails "The super keyword without explicit arguments passes arguments and rest arguments including any modifications"
-  fails "The super keyword without explicit arguments passes optional arguments that have a default value"
   fails "The super keyword without explicit arguments passes optional arguments that have a default value but were modified"
+  fails "The super keyword without explicit arguments passes optional arguments that have a default value"
   fails "The super keyword without explicit arguments passes optional arguments that have a non-default value but were modified"
   fails "The super keyword without explicit arguments passes rest arguments including any modifications"
   fails "The unpacking splat operator (*) unpacks arguments as if they were listed statically"
@@ -162,4 +222,19 @@ opal_filter "language" do
   fails "The until modifier with begin .. end block restart the current iteration without reevaluting condition with redo"
   fails "The until modifier with begin .. end block runs block at least once (even if the expression is true)"
   fails "The until modifier with begin .. end block skips to end of body with next"
+  fails "The while expression stops running body if interrupted by break in a begin ... end attribute op-assign-or value"
+  fails "The while expression stops running body if interrupted by break in a begin ... end element op-assign value"
+  fails "The while expression stops running body if interrupted by break in a begin ... end element op-assign-or value"
+  fails "The while expression stops running body if interrupted by break in a parenthesized attribute op-assign-or value"
+  fails "The while expression stops running body if interrupted by break in a parenthesized element op-assign value"
+  fails "The while modifier with begin .. end block evaluates condition after block execution"
+  fails "The while modifier with begin .. end block restarts the current iteration without reevaluting condition with redo"
+  fails "The while modifier with begin .. end block runs block at least once (even if the expression is false)"
+  fails "The while modifier with begin .. end block skips to end of body with next"
+  fails "calling methods on the metaclass calls a method defined on the metaclass of the metaclass"
+  fails "not() returns false if the argument is true"
+  fails "not() returns true if the argument is false"
+  fails "not() returns true if the argument is nil"
+  fails "self in a metaclass body (class << obj) raises a TypeError for numbers"
+  fails "self in a metaclass body (class << obj) raises a TypeError for symbols"
 end

data/spec/filters/bugs/module.rb

@@ -1,22 +1,5 @@
 opal_filter "Module" do
-  fails "Module#< raises a TypeError if the argument is not a class/module"
-  fails "Module#< returns nil if self is not related to the given module"
-  fails "Module#< returns true if self is a subclass of or includes the given module"
-  fails "Module#<= raises a TypeError if the argument is not a class/module"
-  fails "Module#<= returns nil if self is not related to the given module"
-  fails "Module#<= returns true if self is a subclass of, the same as or includes the given module"
-  fails "Module#<=> returns +1 if self is a superclas of or included by the given module"
-  fails "Module#<=> returns -1 if self is a subclass of or includes the given module"
   fails "Module#=== returns true when the given Object's class includes self or when the given Object is extended by self"
-  fails "Module#> raises a TypeError if the argument is not a class/module"
-  fails "Module#> returns false if self is a subclass of or includes the given module"
-  fails "Module#> returns false if self is the same as the given module"
-  fails "Module#> returns nil if self is not related to the given module"
-  fails "Module#> returns true if self is a superclass of or included by the given module"
-  fails "Module#>= raises a TypeError if the argument is not a class/module"
-  fails "Module#>= returns false if self is a subclass of or includes the given module"
-  fails "Module#>= returns nil if self is not related to the given module"
-  fails "Module#>= returns true if self is a superclass of, the same as or included by given module"
   fails "Module#alias_method can call a method with super aliased twice"
   fails "Module#alias_method preserves the arguments information of the original methods"
   fails "Module#alias_method raises a TypeError when the given name can't be converted using to_str"
@@ -44,6 +27,46 @@ opal_filter "Module" do
   fails "Module#attr_writer converts non string/symbol/fixnum names to strings using to_str"
   fails "Module#attr_writer not allows for adding an attr_writer to an immediate"
   fails "Module#attr_writer raises a TypeError when the given names can't be converted to strings using to_str"
+  fails "Module#autoload (concurrently) blocks a second thread while a first is doing the autoload"
+  fails "Module#autoload (concurrently) blocks others threads while doing an autoload"
+  fails "Module#autoload allows multiple autoload constants for a single file"
+  fails "Module#autoload calls #to_path on non-String filename arguments"
+  fails "Module#autoload calls #to_path on non-string filenames"
+  fails "Module#autoload does NOT raise a NameError when the autoload file did not define the constant and a module is opened with the same name"
+  fails "Module#autoload does not load the file if the file is manually required"
+  fails "Module#autoload does not load the file when accessing the constants table of the module"
+  fails "Module#autoload does not load the file when refering to the constant in defined?"
+  fails "Module#autoload does not remove the constant from the constant table if load fails"
+  fails "Module#autoload does not remove the constant from the constant table if the loaded files does not define it"
+  fails "Module#autoload ignores the autoload request if the file is already loaded"
+  fails "Module#autoload loads a file with .rb extension when passed the name without the extension"
+  fails "Module#autoload loads the file that defines subclass XX::YY < YY and YY is a top level constant"
+  fails "Module#autoload loads the file when opening a module that is the autoloaded constant"
+  fails "Module#autoload loads the registered constant into a dynamically created class"
+  fails "Module#autoload loads the registered constant into a dynamically created module"
+  fails "Module#autoload loads the registered constant when it is accessed"
+  fails "Module#autoload loads the registered constant when it is included"
+  fails "Module#autoload loads the registered constant when it is inherited from"
+  fails "Module#autoload loads the registered constant when it is opened as a class"
+  fails "Module#autoload loads the registered constant when it is opened as a module"
+  fails "Module#autoload looks up the constant in the scope where it is referred"
+  fails "Module#autoload looks up the constant when in a meta class scope"
+  fails "Module#autoload on a frozen module raises a RuntimeError before setting the name"
+  fails "Module#autoload raises a NameError when the constant name has a space in it"
+  fails "Module#autoload raises a NameError when the constant name starts with a lower case letter"
+  fails "Module#autoload raises a NameError when the constant name starts with a number"
+  fails "Module#autoload raises a TypeError if not passed a String or object respodning to #to_path for the filename"
+  fails "Module#autoload raises a TypeError if opening a class with a different superclass than the class defined in the autoload file"
+  fails "Module#autoload raises an ArgumentError when an empty filename is given"
+  fails "Module#autoload registers a file to load the first time the named constant is accessed"
+  fails "Module#autoload retains the autoload even if the request to require fails"
+  fails "Module#autoload returns 'constant' on refering the constant with defined?()"
+  fails "Module#autoload runs for an exception condition class and doesn't trample the exception"
+  fails "Module#autoload sets the autoload constant in the constants table"
+  fails "Module#autoload shares the autoload request across dup'ed copies of modules"
+  fails "Module#autoload when changing $LOAD_PATH does not reload a file due to a different load path"
+  fails "Module#autoload? returns nil if no file has been registered for a constant"
+  fails "Module#autoload? returns the name of the file that will be autoloaded"
   fails "Module#class_eval adds methods respecting the lexical constant scope"
   fails "Module#class_eval converts a non-string filename to a string using to_str"
   fails "Module#class_eval converts non string eval-string to string using to_str"
@@ -81,6 +104,9 @@ opal_filter "Module" do
   fails "Module#const_get with dynamically assigned constants searches a module included in the superclass"
   fails "Module#const_get with dynamically assigned constants searches the superclass chain"
   fails "Module#const_missing raises NameError and does not include toplevel Object"
+  fails "Module#const_set calls #to_str to convert the given name to a String"
+  fails "Module#const_set on a frozen module raises a RuntimeError before setting the name"
+  fails "Module#const_set raises a TypeError if conversion to a String by calling #to_str fails"
   fails "Module#constants doesn't returns inherited constants when passed false"
   fails "Module#constants doesn't returns inherited constants when passed nil"
   fails "Module#constants includes names of constants defined after a module is included"
@@ -150,6 +176,10 @@ opal_filter "Module" do
   fails "Module#module_function on Class raises a TypeError if calling after rebinded to Class"
   fails "Module#module_function with specific method names raises a TypeError when the given names can't be converted to string using to_str"
   fails "Module#module_function with specific method names tries to convert the given names to strings using to_str"
+  fails "Module#name is not nil for a nested module created with the module keyword"
+  fails "Module#name is set with a conditional assignment to a constant"
+  fails "Module#name is set with a conditional assignment to a nested constant"
+  fails "Module#name preserves the encoding in which the class was defined"
   fails "Module#prepend accepts no-arguments"
   fails "Module#prepend adds the module in the subclass chains"
   fails "Module#prepend allows wrapping methods"

data/spec/filters/bugs/proc.rb

@@ -4,13 +4,47 @@ opal_filter "Proc" do
   fails "Proc as an implicit block pass argument remains the same object if re-vivified by the target method"
   fails "Proc#=== on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on excess arguments when self is a lambda"
   fails "Proc#=== on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on missing arguments when self is a lambda"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (*) { }\n    @b = -> (*a) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (**k, &l) { }\n    @b= -> (*a, **k) { }\n    @c = ->(a: 1, b: 2, **k) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (*a, b) { }\n    @b = -> (*a, b, c) { }\n    @c = -> (*a, b, c, d) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a, *) { }\n    @b = -> (a, *b) { }\n    @c = -> (a, b, *c) { }\n    @d = -> (a, b, c, *d) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a, *b, c) { }\n    @b = -> (a, b, *c, d, e) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a, b=1) { }\n    @b = -> (a, b, c=1, d=2) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a, b=1, *c, d, e:, f: 2, **k, &l) { }\n    @b = -> (a, b=1, *c, d:, e:, f: 2, **k, &l) { }\n    @c = -> (a=0, b=1, *c, d, e:, f: 2, **k, &l) { }\n    @d = -> (a=0, b=1, *c, d:, e:, f: 2, **k, &l) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a, b=1, c=2, *d, e, f) { }\n    @b = -> (a, b, c=1, *d, e, f, g) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a: 1) { }\n    @b = -> (a: 1, b: 2) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a=1) { }\n    @b = -> (a=1, b=2) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a=1, *b) { }\n    @b = -> (a=1, b=2, *c) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a=1, *b, c:, d: 2, **k, &l) { }"
+  fails "Proc#arity for instances created with -> () { } returns negative values for definition \n    @a = -> (a=1, b: 2) { }\n    @b = -> (*a, b: 1) { }\n    @c = -> (a=1, b: 2) { }\n    @d = -> (a=1, *b, c: 2, &l) { }"
+  fails "Proc#arity for instances created with -> () { } returns positive values for definition \n    @a = -> ((a, (*b, c))) { }\n    @b = -> (a, (*b, c), d, (*e), (*)) { }"
+  fails "Proc#arity for instances created with -> () { } returns positive values for definition \n    @a = -> (a, b, c:, d: 1) { }\n    @b = -> (a, b, c:, d: 1, **k, &l) { }"
+  fails "Proc#arity for instances created with -> () { } returns positive values for definition \n    @a = -> (a, b:) { }\n    @b = -> (a, b:, &l) { }"
+  fails "Proc#arity for instances created with -> () { } returns positive values for definition \n    @a = -> (a:) { }\n    @b = -> (a:, b:) { }\n    @c = -> (a: 1, b:, c:, d: 2) { }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |(a, (*b, c)), d=1| }\n    @b = lambda { |a, (*b, c), d, (*e), (*), **k| }\n    @c = lambda { |a, (b, c), *, d:, e: 2, **| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |**k, &l| }\n    @b = lambda { |*a, **k| }\n    @c = lambda { |a: 1, b: 2, **k| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |*a, b| }\n    @b = lambda { |*a, b, c| }\n    @c = lambda { |*a, b, c, d| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |*| }\n    @b = lambda { |*a| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a, *b, c| }\n    @b = lambda { |a, b, *c, d, e| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a, *| }\n    @b = lambda { |a, *b| }\n    @c = lambda { |a, b, *c| }\n    @d = lambda { |a, b, c, *d| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a, b=1, *c, d, e:, f: 2, **k, &l| }\n    @b = lambda { |a, b=1, *c, d:, e:, f: 2, **k, &l| }\n    @c = lambda { |a=0, b=1, *c, d, e:, f: 2, **k, &l| }\n    @d = lambda { |a=0, b=1, *c, d:, e:, f: 2, **k, &l| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a, b=1, c=2, *d, e, f| }\n    @b = lambda { |a, b, c=1, *d, e, f, g| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a, b=1| }\n    @b = lambda { |a, b, c=1, d=2| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a: 1| }\n    @b = lambda { |a: 1, b: 2| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a=1, *b, c:, d: 2, **k, &l| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a=1, *b| }\n    @b = lambda { |a=1, b=2, *c| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a=1, b: 2| }\n    @b = lambda { |*a, b: 1| }\n    @c = lambda { |a=1, b: 2| }\n    @d = lambda { |a=1, *b, c: 2, &l| }"
+  fails "Proc#arity for instances created with lambda { || } returns negative values for definition \n    @a = lambda { |a=1| }\n    @b = lambda { |a=1, b=2| }"
+  fails "Proc#arity for instances created with lambda { || } returns positive values for definition \n    @a = lambda { |a, b, c:, d: 1| }\n    @b = lambda { |a, b, c:, d: 1, **k, &l| }"
+  fails "Proc#arity for instances created with lambda { || } returns positive values for definition \n    @a = lambda { |a, b:| }\n    @b = lambda { |a, b:, &l| }"
+  fails "Proc#arity for instances created with lambda { || } returns positive values for definition \n    @a = lambda { |a:| }\n    @b = lambda { |a:, b:| }\n    @c = lambda { |a: 1, b:, c:, d: 2| }"
   fails "Proc#binding returns a Binding instance"
   fails "Proc#binding returns the binding associated with self"
   fails "Proc#call on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on excess arguments when self is a lambda"
   fails "Proc#call on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on missing arguments when self is a lambda"
   fails "Proc#curry with arity argument returns Procs with arities of -1 regardless of the value of _arity_"
-  fails "Proc#inspect for a proc created with lambda returns a description including '(lambda)' and optionally including file and line number"
   fails "Proc#inspect for a proc created with UnboundMethod#to_proc returns a description including '(lambda)' and optionally including file and line number"
+  fails "Proc#inspect for a proc created with lambda returns a description including '(lambda)' and optionally including file and line number"
   fails "Proc#lambda? is preserved when passing a Proc with & to the lambda keyword"
   fails "Proc#lambda? is preserved when passing a Proc with & to the proc keyword"
   fails "Proc#source_location returns an Array"
@@ -19,8 +53,8 @@ opal_filter "Proc" do
   fails "Proc#source_location sets the first value to the path of the file in which the proc was defined"
   fails "Proc#source_location sets the last value to a Fixnum representing the line on which the proc was defined"
   fails "Proc#source_location works even if the proc was created on the same line"
-  fails "Proc#to_s for a proc created with lambda returns a description including '(lambda)' and optionally including file and line number"
   fails "Proc#to_s for a proc created with UnboundMethod#to_proc returns a description including '(lambda)' and optionally including file and line number"
+  fails "Proc#to_s for a proc created with lambda returns a description including '(lambda)' and optionally including file and line number"
   fails "Proc#yield on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on excess arguments when self is a lambda"
   fails "Proc#yield on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on missing arguments when self is a lambda"
   fails "Proc.allocate raises a TypeError"