opal 0.10.0 → 0.11.0

data/opal/corelib/helpers.rb

@@ -90,21 +90,8 @@ module Opal
     obj.respond_to? method
   end
 
-  def self.inspect(obj)
-    %x{
-      if (obj === undefined) {
-        return "undefined";
-      }
-      else if (obj === null) {
-        return "null";
-      }
-      else if (!obj.$$class) {
-        return obj.toString();
-      }
-      else {
-        return #{obj.inspect};
-      }
-    }
+  def self.inspect_obj(obj)
+    `Opal.inspect(obj)`
   end
 
   def self.instance_variable_name!(name)
@@ -117,6 +104,16 @@ module Opal
     name
   end
 
+  def self.class_variable_name!(name)
+    name = Opal.coerce_to!(name, String, :to_str)
+
+    if `name.length < 3 || name.slice(0,2) !== '@@'`
+      raise NameError.new("`#{name}' is not allowed as a class variable name", name)
+    end
+
+    name
+  end
+
   def self.const_name!(const_name)
     const_name = Opal.coerce_to!(const_name, String, :to_str)
 

data/opal/corelib/io.rb

@@ -69,8 +69,9 @@ STDERR = $stderr = IO.new
 STDIN  = $stdin  = IO.new
 STDOUT = $stdout = IO.new
 
-STDOUT.write_proc = `typeof(process) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
-STDERR.write_proc = `typeof(process) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
+`var console = Opal.global.console`
+STDOUT.write_proc = `typeof(process) === 'object' && typeof(process.stdout) === 'object' ? function(s){process.stdout.write(s)} : function(s){console.log(s)}`
+STDERR.write_proc = `typeof(process) === 'object' && typeof(process.stderr) === 'object' ? function(s){process.stderr.write(s)} : function(s){console.warn(s)}`
 
 STDOUT.extend(IO::Writable)
 STDERR.extend(IO::Writable)

data/opal/corelib/kernel.rb

@@ -38,7 +38,7 @@ module Kernel
         #{raise NameError.new("undefined method `#{name}' for class `#{self.class}'", name)};
       }
 
-      return #{Method.new(self, `meth`, name)};
+      return #{Method.new(self, `meth.$$owner || #{self.class}`, `meth`, name)};
     }
   end
 
@@ -94,7 +94,7 @@ module Kernel
 
   # Opal does not support #caller, but we stub it as an empty array to not
   # break dependant libs
-  def caller
+  def caller(*args)
     []
   end
 
@@ -104,8 +104,10 @@ module Kernel
 
   def copy_instance_variables(other)
     %x{
-      for (var name in other) {
-        if (other.hasOwnProperty(name) && name.charAt(0) !== '$') {
+      var keys = Object.keys(other), i, ii, name;
+      for (i = 0, ii = keys.length; i < ii; i++) {
+        name = keys[i];
+        if (name.charAt(0) !== '$' && other.hasOwnProperty(name)) {
           self[name] = other[name];
         }
       }
@@ -135,7 +137,7 @@ module Kernel
     }
   end
 
-  def clone
+  def clone(freeze: true)
     copy = self.class.allocate
 
     copy.copy_instance_variables(self)
@@ -184,8 +186,19 @@ module Kernel
       block.call
     end
 
-    status = 0 if `status === true` # it's in JS because it can be null/undef
-    `Opal.exit(status);`
+    %x{
+      if (status == null) {
+        status = 0
+      } else if (status.$$is_boolean) {
+        status = status ? 0 : 1;
+      } else if (status.$$is_numeric) {
+        status = status.$to_i();
+      } else {
+        status = 0
+      }
+
+      Opal.exit(status);
+    }
     nil
   end
 
@@ -853,6 +866,10 @@ module Kernel
         return #{Opal.coerce_to!(value, Integer, :to_i)};
       }
 
+      if (value === "0") {
+        return 0;
+      }
+
       if (base === undefined) {
         base = 0;
       } else {
@@ -956,6 +973,10 @@ module Kernel
     }
   end
 
+  def itself
+    self
+  end
+
   alias kind_of? is_a?
 
   def lambda(&block)
@@ -970,13 +991,15 @@ module Kernel
   end
 
   def loop
-    return enum_for :loop unless block_given?
-
-    %x{
-      while (true) {
-        #{yield}
-      }
-    }
+    return enum_for(:loop) { Float::INFINITY } unless block_given?
+
+    while true do
+      begin
+        yield
+      rescue StopIteration => e
+        return e.result
+      end
+    end
 
     self
   end
@@ -1059,19 +1082,24 @@ module Kernel
   def rand(max = undefined)
     %x{
       if (max === undefined) {
-        return Math.random();
+        return #{Random::DEFAULT.rand};
       }
-      else if (max.$$is_range) {
-        var min = max.begin, range = max.end - min;
-        if(!max.exclude) range++;
 
-        return self.$rand(range) + min;
-      }
-      else {
-        return Math.floor(Math.random() *
-          Math.abs(#{Opal.coerce_to max, Integer, :to_int}));
+      if (max.$$is_number) {
+        if (max < 0) {
+          max = Math.abs(max);
+        }
+
+        if (max % 1 !== 0) {
+          max = max.$to_i();
+        }
+
+        if (max === 0) {
+          max = undefined;
+        }
       }
     }
+    Random::DEFAULT.rand(max)
   end
 
   def respond_to?(name, include_all = false)
@@ -1106,18 +1134,20 @@ module Kernel
 
   # `path` should be the full path to be found in registered modules (`Opal.modules`)
   def require_tree(path)
-    path = File.expand_path(path)
-    path = '' if path == '.'
-
     %x{
+      var result = [];
+
+      path = #{File.expand_path(path)}
+      path = Opal.normalize(path);
+      if (path === '.') path = '';
       for (var name in Opal.modules) {
         if (#{`name`.start_with?(path)}) {
-          Opal.require(name);
+          result.push([name, Opal.require(name)]);
         }
       }
-    }
 
-    nil
+      return result;
+    }
   end
 
   alias send        __send__
@@ -1138,15 +1168,21 @@ module Kernel
       if (seconds < 0) {
         #{raise ArgumentError, "time interval must be positive"}
       }
-      var t = new Date();
-      while (new Date() - t <= seconds * 1000);
+      var get_time = Opal.global.performance ?
+        function() {return performance.now()} :
+        function() {return new Date()}
+
+      var t = get_time();
+      while (get_time() - t <= seconds * 1000);
       return seconds;
     }
   end
 
   alias sprintf format
 
-  alias srand rand
+  def srand(seed = Random.new_seed)
+    Random.srand(seed)
+  end
 
   def String(str)
     Opal.coerce_to?(str, String, :to_str) ||