opal 1.3.1 → 1.4.1

data/opal/corelib/kernel.rb

@@ -1,10 +1,7 @@
-# helpers: truthy, coerce_to, respond_to
-
-module Kernel
-  def method_missing(symbol, *args, &block)
-    raise NoMethodError.new("undefined method `#{symbol}' for #{inspect}", symbol, args), nil, caller(1)
-  end
+# helpers: truthy, coerce_to, respond_to, Opal
+# use_strict: true
 
+module ::Kernel
   def =~(obj)
     false
   end
@@ -37,10 +34,10 @@ module Kernel
       var meth = self['$' + name];
 
       if (!meth || meth.$$stub) {
-        #{raise NameError.new("undefined method `#{name}' for class `#{self.class}'", name)};
+        #{::Kernel.raise ::NameError.new("undefined method `#{name}' for class `#{self.class}'", name)};
       }
 
-      return #{Method.new(self, `meth.$$owner || #{self.class}`, `meth`, name)};
+      return #{::Method.new(self, `meth.$$owner || #{self.class}`, `meth`, name)};
     }
   end
 
@@ -76,10 +73,10 @@ module Kernel
         return object;
       }
 
-      coerced = #{Opal.coerce_to?(object, Array, :to_ary)};
+      coerced = #{::Opal.coerce_to?(object, ::Array, :to_ary)};
       if (coerced !== nil) { return coerced; }
 
-      coerced = #{Opal.coerce_to?(object, Array, :to_a)};
+      coerced = #{::Opal.coerce_to?(object, ::Array, :to_a)};
       if (coerced !== nil) { return coerced; }
 
       return [object];
@@ -189,11 +186,9 @@ module Kernel
   end
 
   def enum_for(method = :each, *args, &block)
-    Enumerator.for(self, method, *args, &block)
+    ::Enumerator.for(self, method, *args, &block)
   end
 
-  alias to_enum enum_for
-
   def equal?(other)
     `self === other`
   end
@@ -210,7 +205,7 @@ module Kernel
       if (status.$$is_boolean) {
         status = status ? 0 : 1;
       } else {
-        status = $coerce_to(status, #{Integer}, 'to_int')
+        status = $coerce_to(status, #{::Integer}, 'to_int')
       }
 
       Opal.exit(status);
@@ -226,7 +221,7 @@ module Kernel
         var mod = mods[i];
 
         if (!mod.$$is_module) {
-          #{raise TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
+          #{::Kernel.raise ::TypeError, "wrong argument type #{`mod`.class} (expected Module)"};
         }
 
         #{`mod`.append_features `singleton`};
@@ -249,20 +244,33 @@ module Kernel
   def initialize_copy(other)
   end
 
+  `var inspect_stack = []`
+
   def inspect
     ivs = ''
-    instance_variables.each do |i|
-      ivs += " #{i}=#{instance_variable_get(i).inspect}"
+    id = __id__
+    if `inspect_stack`.include? id
+      ivs = ' ...'
+    else
+      `inspect_stack` << id
+      pushed = true
+      instance_variables.each do |i|
+        ivar = instance_variable_get(i)
+        inspect = Opal.inspect(ivar)
+        ivs += " #{i}=#{inspect}"
+      end
     end
-    "#<#{self.class}:0x#{__id__.to_s(16)}#{ivs}>"
-  rescue
-    "#<#{self.class}:0x#{__id__.to_s(16)}>"
+    "#<#{self.class}:0x#{id.to_s(16)}#{ivs}>"
+  rescue => e
+    "#<#{self.class}:0x#{id.to_s(16)}>"
+  ensure
+    `inspect_stack`.pop if pushed
   end
 
   def instance_of?(klass)
     %x{
       if (!klass.$$is_class && !klass.$$is_module) {
-        #{raise TypeError, 'class or module required'};
+        #{::Kernel.raise ::TypeError, 'class or module required'};
       }
 
       return self.$$class === klass;
@@ -270,13 +278,13 @@ module Kernel
   end
 
   def instance_variable_defined?(name)
-    name = Opal.instance_variable_name!(name)
+    name = ::Opal.instance_variable_name!(name)
 
     `Opal.hasOwnProperty.call(self, name.substr(1))`
   end
 
   def instance_variable_get(name)
-    name = Opal.instance_variable_name!(name)
+    name = ::Opal.instance_variable_name!(name)
 
     %x{
       var ivar = self[Opal.ivar(name.substr(1))];
@@ -286,13 +294,13 @@ module Kernel
   end
 
   def instance_variable_set(name, value)
-    name = Opal.instance_variable_name!(name)
+    name = ::Opal.instance_variable_name!(name)
 
     `self[Opal.ivar(name.substr(1))] = value`
   end
 
   def remove_instance_variable(name)
-    name = Opal.instance_variable_name!(name)
+    name = ::Opal.instance_variable_name!(name)
 
     %x{
       var key = Opal.ivar(name.substr(1)),
@@ -304,7 +312,7 @@ module Kernel
       }
     }
 
-    raise NameError, "instance variable #{name} not defined"
+    ::Kernel.raise ::NameError, "instance variable #{name} not defined"
   end
 
   def instance_variables
@@ -332,14 +340,14 @@ module Kernel
 
       if (!value.$$is_string) {
         if (base !== undefined) {
-          #{raise ArgumentError, 'base specified for non string value'}
+          #{::Kernel.raise ::ArgumentError, 'base specified for non string value'}
         }
         if (value === nil) {
-          #{raise TypeError, "can't convert nil into Integer"}
+          #{::Kernel.raise ::TypeError, "can't convert nil into Integer"}
         }
         if (value.$$is_number) {
           if (value === Infinity || value === -Infinity || isNaN(value)) {
-            #{raise FloatDomainError, value}
+            #{::Kernel.raise ::FloatDomainError, value}
           }
           return Math.floor(value);
         }
@@ -349,7 +357,7 @@ module Kernel
             return i;
           }
         }
-        return #{Opal.coerce_to!(value, Integer, :to_i)};
+        return #{::Opal.coerce_to!(value, ::Integer, :to_i)};
       }
 
       if (value === "0") {
@@ -359,9 +367,9 @@ module Kernel
       if (base === undefined) {
         base = 0;
       } else {
-        base = $coerce_to(base, #{Integer}, 'to_int');
+        base = $coerce_to(base, #{::Integer}, 'to_int');
         if (base === 1 || base < 0 || base > 36) {
-          #{raise ArgumentError, "invalid radix #{base}"}
+          #{::Kernel.raise ::ArgumentError, "invalid radix #{base}"}
         }
       }
 
@@ -397,7 +405,7 @@ module Kernel
           }
           // no-break
         }
-        #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
       });
 
       base = (base === 0 ? 10 : base);
@@ -405,13 +413,13 @@ module Kernel
       base_digits = '0-' + (base <= 10 ? base - 1 : '9a-' + String.fromCharCode(97 + (base - 11)));
 
       if (!(new RegExp('^\\s*[+-]?[' + base_digits + ']+\\s*$')).test(str)) {
-        #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
       }
 
       i = parseInt(str, base);
 
       if (isNaN(i)) {
-        #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
+        #{::Kernel.raise ::ArgumentError, "invalid value for Integer(): \"#{value}\""}
       }
 
       return i;
@@ -423,7 +431,7 @@ module Kernel
       var str;
 
       if (value === nil) {
-        #{raise TypeError, "can't convert nil into Float"}
+        #{::Kernel.raise ::TypeError, "can't convert nil into Float"}
       }
 
       if (value.$$is_string) {
@@ -433,30 +441,30 @@ module Kernel
 
         //Special case for hex strings only:
         if (/^\s*[-+]?0[xX][0-9a-fA-F]+\s*$/.test(str)) {
-          return #{Integer(`str`)};
+          return #{::Kernel.Integer(`str`)};
         }
 
         if (!/^\s*[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\s*$/.test(str)) {
-          #{raise ArgumentError, "invalid value for Float(): \"#{value}\""}
+          #{::Kernel.raise ::ArgumentError, "invalid value for Float(): \"#{value}\""}
         }
 
         return parseFloat(str);
       }
 
-      return #{Opal.coerce_to!(value, Float, :to_f)};
+      return #{::Opal.coerce_to!(value, ::Float, :to_f)};
     }
   end
 
   def Hash(arg)
     return {} if arg.nil? || arg == []
-    return arg if Hash === arg
-    Opal.coerce_to!(arg, Hash, :to_hash)
+    return arg if ::Hash === arg
+    ::Opal.coerce_to!(arg, ::Hash, :to_hash)
   end
 
   def is_a?(klass)
     %x{
       if (!klass.$$is_class && !klass.$$is_module) {
-        #{raise TypeError, 'class or module required'};
+        #{::Kernel.raise ::TypeError, 'class or module required'};
       }
 
       return Opal.is_a(self, klass);
@@ -467,24 +475,22 @@ module Kernel
     self
   end
 
-  alias kind_of? is_a?
-
   def lambda(&block)
     `Opal.lambda(block)`
   end
 
   def load(file)
-    file = Opal.coerce_to!(file, String, :to_str)
+    file = ::Opal.coerce_to!(file, ::String, :to_str)
     `Opal.load(#{file})`
   end
 
   def loop
-    return enum_for(:loop) { Float::INFINITY } unless block_given?
+    return enum_for(:loop) { ::Float::INFINITY } unless block_given?
 
     while true
       begin
         yield
-      rescue StopIteration => e
+      rescue ::StopIteration => e
         return e.result
       end
     end
@@ -496,8 +502,6 @@ module Kernel
     false
   end
 
-  alias object_id __id__
-
   def printf(*args)
     if args.any?
       print format(*args)
@@ -508,7 +512,7 @@ module Kernel
 
   def proc(&block)
     unless block
-      raise ArgumentError, 'tried to create Proc object without a block'
+      ::Kernel.raise ::ArgumentError, 'tried to create Proc object without a block'
     end
 
     `block.$$is_lambda = false`
@@ -535,8 +539,8 @@ module Kernel
 
   def warn(*strs, uplevel: nil)
     if uplevel
-      uplevel = Opal.coerce_to!(uplevel, Integer, :to_str)
-      raise ArgumentError, "negative level (#{uplevel})" if uplevel < 0
+      uplevel = ::Opal.coerce_to!(uplevel, ::Integer, :to_str)
+      ::Kernel.raise ::ArgumentError, "negative level (#{uplevel})" if uplevel < 0
       location = caller(uplevel + 1, 1).first&.split(':in `')&.first
       location = "#{location}: " if location
       strs = strs.map { |s| "#{location}warning: #{s}" }
@@ -551,10 +555,10 @@ module Kernel
         throw #{$!};
       }
       if (exception == null) {
-        exception = #{RuntimeError.new ''};
+        exception = #{::RuntimeError.new ''};
       }
       else if ($respond_to(exception, '$to_str')) {
-        exception = #{RuntimeError.new exception.to_str};
+        exception = #{::RuntimeError.new exception.to_str};
       }
       // using respond_to? and not an undefined check to avoid method_missing matching as true
       else if (exception.$$is_class && $respond_to(exception, '$exception')) {
@@ -564,7 +568,7 @@ module Kernel
         // exception is fine
       }
       else {
-        exception = #{TypeError.new 'exception class/object expected'};
+        exception = #{::TypeError.new 'exception class/object expected'};
       }
 
       if (backtrace !== nil) {
@@ -582,12 +586,10 @@ module Kernel
     }
   end
 
-  alias fail raise
-
   def rand(max = undefined)
     %x{
       if (max === undefined) {
-        return #{Random::DEFAULT.rand};
+        return #{::Random::DEFAULT.rand};
       }
 
       if (max.$$is_number) {
@@ -604,7 +606,7 @@ module Kernel
         }
       }
     }
-    Random::DEFAULT.rand(max)
+    ::Random::DEFAULT.rand(max)
   end
 
   def respond_to?(name, include_all = false)
@@ -627,22 +629,22 @@ module Kernel
     false
   end
 
-  Opal.pristine(self, :respond_to?, :respond_to_missing?)
+  ::Opal.pristine(self, :respond_to?, :respond_to_missing?)
 
   def require(file)
     %x{
       // As Object.require refers to Kernel.require once Kernel has been loaded the String
       // class may not be available yet, the coercion requires both  String and Array to be loaded.
       if (typeof #{file} !== 'string' && Opal.String && Opal.Array) {
-        #{file = Opal.coerce_to!(file, String, :to_str) }
+        #{file = ::Opal.coerce_to!(file, ::String, :to_str) }
       }
       return Opal.require(#{file})
     }
   end
 
   def require_relative(file)
-    Opal.try_convert!(file, String, :to_str)
-    file = File.expand_path File.join(`Opal.current_file`, '..', file)
+    ::Opal.try_convert!(file, ::String, :to_str)
+    file = ::File.expand_path ::File.join(`Opal.current_file`, '..', file)
 
     `Opal.require(#{file})`
   end
@@ -652,7 +654,7 @@ module Kernel
     %x{
       var result = [];
 
-      path = #{File.expand_path(path)}
+      path = #{::File.expand_path(path)}
       path = Opal.normalize(path);
       if (path === '.') path = '';
       for (var name in Opal.modules) {
@@ -669,9 +671,6 @@ module Kernel
     }
   end
 
-  alias send        __send__
-  alias public_send __send__
-
   def singleton_class
     `Opal.get_singleton_class(self)`
   end
@@ -679,13 +678,13 @@ module Kernel
   def sleep(seconds = nil)
     %x{
       if (seconds === nil) {
-        #{raise TypeError, "can't convert NilClass into time interval"}
+        #{::Kernel.raise ::TypeError, "can't convert NilClass into time interval"}
       }
       if (!seconds.$$is_number) {
-        #{raise TypeError, "can't convert #{seconds.class} into time interval"}
+        #{::Kernel.raise ::TypeError, "can't convert #{seconds.class} into time interval"}
       }
       if (seconds < 0) {
-        #{raise ArgumentError, 'time interval must be positive'}
+        #{::Kernel.raise ::ArgumentError, 'time interval must be positive'}
       }
       var get_time = Opal.global.performance ?
         function() {return performance.now()} :
@@ -698,12 +697,12 @@ module Kernel
   end
 
   def srand(seed = Random.new_seed)
-    Random.srand(seed)
+    ::Random.srand(seed)
   end
 
   def String(str)
-    Opal.coerce_to?(str, String, :to_str) ||
-      Opal.coerce_to!(str, String, :to_s)
+    ::Opal.coerce_to?(str, ::String, :to_str) ||
+      ::Opal.coerce_to!(str, ::String, :to_s)
   end
 
   def tap(&block)
@@ -720,20 +719,20 @@ module Kernel
   end
 
   def catch(tag = nil)
-    tag ||= Object.new
+    tag ||= ::Object.new
     yield(tag)
-  rescue UncaughtThrowError => e
+  rescue ::UncaughtThrowError => e
     return e.value if e.tag == tag
-    raise
+    ::Kernel.raise
   end
 
   def throw(tag, obj = nil)
-    raise UncaughtThrowError.new(tag, obj)
+    ::Kernel.raise ::UncaughtThrowError.new(tag, obj)
   end
 
   # basic implementation of open, delegate to File.open
   def open(*args, &block)
-    File.open(*args, &block)
+    ::File.open(*args, &block)
   end
 
   def yield_self
@@ -741,15 +740,19 @@ module Kernel
     yield self
   end
 
+  alias fail raise
+  alias kind_of? is_a?
+  alias object_id __id__
+  alias public_send __send__
+  alias send __send__
   alias then yield_self
-
-  Opal.pristine(self, :method_missing)
+  alias to_enum enum_for
 end
 
-class Object
+class ::Object
   # Object.require has been set to runtime.js Opal.require
   # Now we have Kernel loaded, make sure Object.require refers to Kernel.require
   # which is what ruby does and allows for overwriting by autoloaders
-  `delete Opal.Object.$$prototype.$require`
-  include Kernel
+  `delete $Object.$$prototype.$require`
+  include ::Kernel
 end

data/opal/corelib/main.rb

@@ -1,16 +1,18 @@
-def self.to_s
-  'main'
-end
+class << self
+  def to_s
+    'main'
+  end
 
-def self.include(mod)
-  Object.include mod
-end
+  def include(mod)
+    ::Object.include mod
+  end
 
-def self.autoload(*args)
-  Object.autoload(*args)
-end
+  def autoload(*args)
+    `Opal.Object.$autoload.apply(Opal.Object, args)`
+  end
 
-# Compiler overrides this method
-def self.using(mod)
-  raise 'main.using is permitted only at toplevel'
+  # Compiler overrides this method
+  def using(mod)
+    ::Kernel.raise 'main.using is permitted only at toplevel'
+  end
 end

data/opal/corelib/marshal/read_buffer.rb

@@ -1,8 +1,8 @@
 # https://github.com/ruby/ruby/blob/trunk/doc/marshal.rdoc
 # https://github.com/ruby/ruby/blob/trunk/marshal.c
 
-module Marshal
-  class ReadBuffer
+module ::Marshal
+  class self::ReadBuffer
     %x{
       function stringToBytes(string) {
         var i,
@@ -26,7 +26,7 @@ module Marshal
       major = read_byte
       minor = read_byte
       if major != MAJOR_VERSION || minor != MINOR_VERSION
-        raise TypeError, "incompatible marshal file format (can't be read)"
+        ::Kernel.raise ::TypeError, "incompatible marshal file format (can't be read)"
       end
       @version = "#{major}.#{minor}"
       @object_cache = []
@@ -89,17 +89,17 @@ module Marshal
       when 'U'
         read_user_marshal
       when 'M'
-        raise NotImplementedError, 'ModuleOld type cannot be demarshaled yet' # read_module_old
+        ::Kernel.raise ::NotImplementedError, 'ModuleOld type cannot be demarshaled yet' # read_module_old
       when 'd'
-        raise NotImplementedError, 'Data type cannot be demarshaled'
+        ::Kernel.raise ::NotImplementedError, 'Data type cannot be demarshaled'
       else
-        raise ArgumentError, 'dump format error'
+        ::Kernel.raise ::ArgumentError, 'dump format error'
       end
     end
 
     def read_byte
       if @index >= length
-        raise ArgumentError, 'marshal data too short'
+        ::Kernel.raise ::ArgumentError, 'marshal data too short'
       end
       result = @buffer[@index]
       @index += 1
@@ -312,7 +312,7 @@ module Marshal
       string = read_string(cache: false)
       options = read_byte
 
-      result = Regexp.new(string, options)
+      result = ::Regexp.new(string, options)
       @object_cache << result
       result
     end
@@ -345,8 +345,8 @@ module Marshal
     def read_class
       klass_name = read_string(cache: false)
       result = safe_const_get(klass_name)
-      unless result.class == Class
-        raise ArgumentError, "#{klass_name} does not refer to a Class"
+      unless result.class == ::Class
+        ::Kernel.raise ::ArgumentError, "#{klass_name} does not refer to a Class"
       end
       @object_cache << result
       result
@@ -362,8 +362,8 @@ module Marshal
     def read_module
       mod_name = read_string(cache: false)
       result = safe_const_get(mod_name)
-      unless result.class == Module
-        raise ArgumentError, "#{mod_name} does not refer to a Module"
+      unless result.class == ::Module
+        ::Kernel.raise ::ArgumentError, "#{mod_name} does not refer to a Module"
       end
       @object_cache << result
       result
@@ -554,9 +554,9 @@ module Marshal
     #  re-raises Marshal-specific error when it's missing
     #
     def safe_const_get(const_name)
-      Object.const_get(const_name)
-    rescue NameError
-      raise ArgumentError, "undefined class/module #{const_name}"
+      ::Object.const_get(const_name)
+    rescue ::NameError
+      ::Kernel.raise ::ArgumentError, "undefined class/module #{const_name}"
     end
   end
 end