opal 1.3.2 → 1.4.0.alpha1

data/opal/corelib/helpers.rb

@@ -1,6 +1,6 @@
 # helpers: type_error, coerce_to
 
-module Opal
+module ::Opal
   def self.bridge(constructor, klass)
     `Opal.bridge(constructor, klass)`
   end
@@ -9,7 +9,7 @@ module Opal
     coerced = `$coerce_to(object, type, method, args)`
 
     unless type === coerced
-      raise `$type_error(object, type, method, coerced)`
+      ::Kernel.raise `$type_error(object, type, method, coerced)`
     end
 
     coerced
@@ -23,7 +23,7 @@ module Opal
     return if coerced.nil?
 
     unless type === coerced
-      raise `$type_error(object, type, method, coerced)`
+      ::Kernel.raise `$type_error(object, type, method, coerced)`
     end
 
     coerced
@@ -41,7 +41,7 @@ module Opal
     compare = a <=> b
 
     if `compare === nil`
-      raise ArgumentError, "comparison of #{a.class} with #{b.class} failed"
+      ::Kernel.raise ::ArgumentError, "comparison of #{a.class} with #{b.class} failed"
     end
 
     compare
@@ -75,20 +75,20 @@ module Opal
   end
 
   def self.instance_variable_name!(name)
-    name = Opal.coerce_to!(name, String, :to_str)
+    name = ::Opal.coerce_to!(name, ::String, :to_str)
 
     unless `/^@[a-zA-Z_][a-zA-Z0-9_]*?$/.test(name)`
-      raise NameError.new("'#{name}' is not allowed as an instance variable name", name)
+      ::Kernel.raise ::NameError.new("'#{name}' is not allowed as an instance variable name", name)
     end
 
     name
   end
 
   def self.class_variable_name!(name)
-    name = Opal.coerce_to!(name, String, :to_str)
+    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)
+      ::Kernel.raise ::NameError.new("`#{name}' is not allowed as a class variable name", name)
     end
 
     name
@@ -97,7 +97,7 @@ module Opal
   def self.const_name?(const_name)
     %x{
       if (typeof const_name !== 'string') {
-        #{const_name = Opal.coerce_to!(const_name, String, :to_str)}
+        #{const_name = ::Opal.coerce_to!(const_name, ::String, :to_str)}
       }
 
       return #{const_name}[0] === #{const_name}[0].toUpperCase()
@@ -105,11 +105,13 @@ module Opal
   end
 
   def self.const_name!(const_name)
-    const_name = Opal.coerce_to!(const_name, String, :to_str)
+    const_name = ::Opal.coerce_to!(const_name, ::String, :to_str) if defined? ::String
 
-    if const_name[0] != const_name[0].upcase
-      raise NameError, "wrong constant name #{const_name}"
-    end
+    %x{
+      if (!const_name || const_name[0] != const_name[0].toUpperCase()) {
+        #{raise ::NameError, "wrong constant name #{const_name}"}
+      }
+    }
 
     const_name
   end
@@ -154,4 +156,51 @@ module Opal
     }
     nil
   end
+
+  `var inspect_stack = []`
+
+  # Performs a safe call to inspect for any value, whether
+  # native or Opal-wrapped.
+  #
+  # @param value [Object]
+  # @return [String]
+  def self.inspect(value = undefined)
+    `var pushed = false`
+    begin
+      %x{
+        if (value === null) {
+          // JS null value
+          return 'null';
+        }
+        else if (value === undefined) {
+          // JS undefined value
+          return 'undefined';
+        }
+        else if (typeof value.$$class === 'undefined') {
+          // JS object / other value that is not bridged
+          return Object.prototype.toString.apply(value);
+        }
+        else if (typeof value.$inspect !== 'function' || value.$inspect.$$stub) {
+          // BasicObject and friends
+          return #{"#<#{`value.$$class`}:0x#{value.__id__.to_s(16)}>"}
+        }
+        else if (inspect_stack.indexOf(#{value.__id__}) !== -1) {
+          // inspect recursing inside inspect to find out about the
+          // same object
+          return #{"#<#{`value.$$class`}:0x#{value.__id__.to_s(16)}>"}
+        }
+        else {
+          // anything supporting Opal
+          inspect_stack.push(#{value.__id__});
+          pushed = true;
+          return value.$inspect();
+        }
+      }
+      nil
+    rescue ::Exception => e # rubocop:disable Lint/RescueException
+      "#<#{`value.$$class`}:0x#{value.__id__.to_s(16)}>"
+    ensure
+      `if (pushed) inspect_stack.pop()`
+    end
+  end
 end

data/opal/corelib/io.rb

@@ -1,12 +1,16 @@
-class IO
-  SEEK_SET = 0
-  SEEK_CUR = 1
-  SEEK_END = 2
-  SEEK_DATA = 3
-  SEEK_HOLE = 4
+class ::IO
+  self::SEEK_SET = 0
+  self::SEEK_CUR = 1
+  self::SEEK_END = 2
+  self::SEEK_DATA = 3
+  self::SEEK_HOLE = 4
 
-  READABLE = 1
-  WRITABLE = 4
+  self::READABLE = 1
+  self::WRITABLE = 4
+
+  attr_reader :eof
+
+  attr_accessor :read_proc,  :sync, :tty, :write_proc
 
   def initialize(fd, flags = 'r')
     @fd = fd
@@ -28,19 +32,11 @@ class IO
     `self.tty == true`
   end
 
-  attr_accessor :write_proc
-  attr_accessor :read_proc
-
   def write(string)
     `self.write_proc(string)`
     string.size
   end
 
-  attr_accessor :sync, :tty
-
-  attr_reader :eof
-  alias eof? eof
-
   def flush
     # noop
   end
@@ -53,7 +49,7 @@ class IO
   def print(*args)
     %x{
       for (var i = 0, ii = args.length; i < ii; i++) {
-        args[i] = #{String(`args[i]`)}
+        args[i] = #{::Kernel.String(`args[i]`)}
       }
       self.$write(args.join(#{$,}));
     }
@@ -62,10 +58,26 @@ class IO
 
   def puts(*args)
     %x{
-      for (var i = 0, ii = args.length; i < ii; i++) {
-        args[i] = #{String(`args[i]`).chomp}
+      var line
+      if (args.length === 0) {
+        #{write "\n"};
+        return nil;
+      } else {
+        for (var i = 0, ii = args.length; i < ii; i++) {
+          if (args[i].$$is_array){
+            var ary = #{`args[i]`.flatten}
+            if (ary.length > 0) #{puts(*`ary`)}
+          } else {
+            if (args[i].$$is_string) {
+              line = args[i].valueOf();
+            } else {
+              line = #{::Kernel.String(`args[i]`)};
+            }
+            if (!line.endsWith("\n")) line += "\n"
+            #{write `line`}
+          }
+        }
       }
-      self.$write(args.concat([nil]).join(#{$/}));
     }
     nil
   end
@@ -99,11 +111,11 @@ class IO
   end
 
   def readchar
-    getc || raise(EOFError, 'end of file reached')
+    getc || ::Kernel.raise(::EOFError, 'end of file reached')
   end
 
   def readline(*args)
-    gets(*args) || raise(EOFError, 'end of file reached')
+    gets(*args) || ::Kernel.raise(::EOFError, 'end of file reached')
   end
 
   def gets(sep = false, limit = nil, opts = {})
@@ -164,14 +176,14 @@ class IO
   def sysread(integer)
     `self.read_proc(integer)` || begin
       @eof = true
-      raise EOFError, 'end of file reached'
+      ::Kernel.raise ::EOFError, 'end of file reached'
     end
   end
 
   # @private
   def sysread_noraise(integer)
     sysread(integer)
-  rescue EOFError
+  rescue ::EOFError
     nil
   end
 
@@ -216,8 +228,6 @@ class IO
     self
   end
 
-  alias each_line each
-
   def each_byte(&block)
     return enum_for :each_byte unless block_given?
 
@@ -275,24 +285,27 @@ class IO
   # @private
   def check_writable
     if closed_write?
-      raise IOError, 'not opened for writing'
+      ::Kernel.raise ::IOError, 'not opened for writing'
     end
   end
 
   # @private
   def check_readable
     if closed_read?
-      raise IOError, 'not opened for reading'
+      ::Kernel.raise ::IOError, 'not opened for reading'
     end
   end
+
+  alias each_line each
+  alias eof? eof
 end
 
-STDIN  = $stdin  = IO.new(0, 'r')
-STDOUT = $stdout = IO.new(1, 'w')
-STDERR = $stderr = IO.new(2, 'w')
+::STDIN  = $stdin  = ::IO.new(0, 'r')
+::STDOUT = $stdout = ::IO.new(1, 'w')
+::STDERR = $stderr = ::IO.new(2, 'w')
 
 `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.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)}`
 
-STDIN.read_proc = `function(s) { var p = prompt(); if (p !== null) return p + "\n"; return nil; }`
+::STDIN.read_proc = `function(s) { var p = prompt(); if (p !== null) return p + "\n"; return nil; }`

data/opal/corelib/kernel/format.rb

@@ -1,9 +1,9 @@
 # helpers: coerce_to
 
-module Kernel
+module ::Kernel
   def format(format_string, *args)
     if args.length == 1 && args[0].respond_to?(:to_ary)
-      ary = Opal.coerce_to?(args[0], Array, :to_ary)
+      ary = ::Opal.coerce_to?(args[0], ::Array, :to_ary)
       args = ary.to_a unless ary.nil?
     end
 
@@ -50,24 +50,24 @@ module Kernel
           FPREC0 = 128;
 
       function CHECK_FOR_FLAGS() {
-        if (flags&FWIDTH) { #{raise ArgumentError, 'flag after width'} }
-        if (flags&FPREC0) { #{raise ArgumentError, 'flag after precision'} }
+        if (flags&FWIDTH) { #{::Kernel.raise ::ArgumentError, 'flag after width'} }
+        if (flags&FPREC0) { #{::Kernel.raise ::ArgumentError, 'flag after precision'} }
       }
 
       function CHECK_FOR_WIDTH() {
-        if (flags&FWIDTH) { #{raise ArgumentError, 'width given twice'} }
-        if (flags&FPREC0) { #{raise ArgumentError, 'width after precision'} }
+        if (flags&FWIDTH) { #{::Kernel.raise ::ArgumentError, 'width given twice'} }
+        if (flags&FPREC0) { #{::Kernel.raise ::ArgumentError, 'width after precision'} }
       }
 
       function GET_NTH_ARG(num) {
-        if (num >= args.length) { #{raise ArgumentError, 'too few arguments'} }
+        if (num >= args.length) { #{::Kernel.raise ::ArgumentError, 'too few arguments'} }
         return args[num];
       }
 
       function GET_NEXT_ARG() {
         switch (pos_arg_num) {
-        case -1: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with numbered"} // raise
-        case -2: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with named"} // raise
+        case -1: #{::Kernel.raise ::ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with numbered"} // raise
+        case -2: #{::Kernel.raise ::ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with named"} // raise
         }
         pos_arg_num = seq_arg_num++;
         return GET_NTH_ARG(pos_arg_num - 1);
@@ -75,13 +75,13 @@ module Kernel
 
       function GET_POS_ARG(num) {
         if (pos_arg_num > 0) {
-          #{raise ArgumentError, "numbered(#{`num`}) after unnumbered(#{`pos_arg_num`})"}
+          #{::Kernel.raise ::ArgumentError, "numbered(#{`num`}) after unnumbered(#{`pos_arg_num`})"}
         }
         if (pos_arg_num === -2) {
-          #{raise ArgumentError, "numbered(#{`num`}) after named"}
+          #{::Kernel.raise ::ArgumentError, "numbered(#{`num`}) after named"}
         }
         if (num < 1) {
-          #{raise ArgumentError, "invalid index - #{`num`}$"}
+          #{::Kernel.raise ::ArgumentError, "invalid index - #{`num`}$"}
         }
         pos_arg_num = -1;
         return GET_NTH_ARG(num - 1);
@@ -95,13 +95,13 @@ module Kernel
         var num, str = '';
         for (;; i++) {
           if (i === len) {
-            #{raise ArgumentError, 'malformed format string - %*[0-9]'}
+            #{::Kernel.raise ::ArgumentError, 'malformed format string - %*[0-9]'}
           }
           if (format_string.charCodeAt(i) < 48 || format_string.charCodeAt(i) > 57) {
             i--;
             num = parseInt(str, 10) || 0;
             if (num > 2147483647) {
-              #{raise ArgumentError, "#{`label`} too big"}
+              #{::Kernel.raise ::ArgumentError, "#{`label`} too big"}
             }
             return num;
           }
@@ -188,7 +188,7 @@ module Kernel
                 break format_sequence;
               }
               if (next_arg !== undefined) {
-                #{raise ArgumentError, "value given twice - %#{`tmp_num`}$"}
+                #{::Kernel.raise ::ArgumentError, "value given twice - %#{`tmp_num`}$"}
               }
               next_arg = GET_POS_ARG(tmp_num);
               i++;
@@ -208,20 +208,20 @@ module Kernel
 
             for (;; i++) {
               if (i === len) {
-                #{raise ArgumentError, 'malformed name - unmatched parenthesis'}
+                #{::Kernel.raise ::ArgumentError, 'malformed name - unmatched parenthesis'}
               }
               if (format_string.charAt(i) === closing_brace_char) {
 
                 if (pos_arg_num > 0) {
-                  #{raise ArgumentError, "named #{`hash_parameter_key`} after unnumbered(#{`pos_arg_num`})"}
+                  #{::Kernel.raise ::ArgumentError, "named #{`hash_parameter_key`} after unnumbered(#{`pos_arg_num`})"}
                 }
                 if (pos_arg_num === -1) {
-                  #{raise ArgumentError, "named #{`hash_parameter_key`} after numbered"}
+                  #{::Kernel.raise ::ArgumentError, "named #{`hash_parameter_key`} after numbered"}
                 }
                 pos_arg_num = -2;
 
                 if (args[0] === undefined || !args[0].$$is_hash) {
-                  #{raise ArgumentError, 'one hash required'}
+                  #{::Kernel.raise ::ArgumentError, 'one hash required'}
                 }
 
                 next_arg = #{`args[0]`.fetch(`hash_parameter_key`)};
@@ -256,7 +256,7 @@ module Kernel
 
           case '.':
             if (flags&FPREC0) {
-              #{raise ArgumentError, 'precision given twice'}
+              #{::Kernel.raise ::ArgumentError, 'precision given twice'}
             }
             flags |= FPREC|FPREC0;
             precision = 0;
@@ -275,7 +275,7 @@ module Kernel
           case 'd':
           case 'i':
           case 'u':
-            arg = #{Integer(`GET_ARG()`)};
+            arg = #{::Kernel.Integer(`GET_ARG()`)};
             if (arg >= 0) {
               str = arg.toString();
               while (str.length < precision) { str = '0' + str; }
@@ -336,7 +336,7 @@ module Kernel
               base_neg_zero_digit = 'f';
               break;
             }
-            arg = #{Integer(`GET_ARG()`)};
+            arg = #{::Kernel.Integer(`GET_ARG()`)};
             if (arg >= 0) {
               str = arg.toString(base_number);
               while (str.length < precision) { str = '0' + str; }
@@ -404,7 +404,7 @@ module Kernel
           case 'E':
           case 'g':
           case 'G':
-            arg = #{Float(`GET_ARG()`)};
+            arg = #{::Kernel.Float(`GET_ARG()`)};
             if (arg >= 0 || isNaN(arg)) {
               if (arg === Infinity) {
                 str = 'Inf';
@@ -483,7 +483,7 @@ module Kernel
           case 'a':
           case 'A':
             // Not implemented because there are no specs for this field type.
-            #{raise NotImplementedError, '`A` and `a` format field types are not implemented in Opal yet'}
+            #{::Kernel.raise ::NotImplementedError, '`A` and `a` format field types are not implemented in Opal yet'}
             // raise
 
           case 'c':
@@ -492,10 +492,10 @@ module Kernel
             if (#{`arg`.respond_to?(:to_str)}) {
               str = #{`arg`.to_str};
             } else {
-              str = String.fromCharCode($coerce_to(arg, #{Integer}, 'to_int'));
+              str = String.fromCharCode($coerce_to(arg, #{::Integer}, 'to_int'));
             }
             if (str.length !== 1) {
-              #{raise ArgumentError, '%c requires a character'}
+              #{::Kernel.raise ::ArgumentError, '%c requires a character'}
             }
             if (flags&FMINUS) {
               while (str.length < width) { str = str + ' '; }
@@ -525,12 +525,12 @@ module Kernel
             break format_sequence;
 
           default:
-            #{raise ArgumentError, "malformed format string - %#{`format_string.charAt(i)`}"}
+            #{::Kernel.raise ::ArgumentError, "malformed format string - %#{`format_string.charAt(i)`}"}
           }
         }
 
         if (str === undefined) {
-          #{raise ArgumentError, 'malformed format string - %'}
+          #{::Kernel.raise ::ArgumentError, 'malformed format string - %'}
         }
 
         result += format_string.slice(begin_slice, end_slice) + str;
@@ -538,7 +538,7 @@ module Kernel
       }
 
       if (#{$DEBUG} && pos_arg_num >= 0 && seq_arg_num < args.length) {
-        #{raise ArgumentError, 'too many arguments for format string'}
+        #{::Kernel.raise ::ArgumentError, 'too many arguments for format string'}
       }
 
       return result + format_string.slice(begin_slice);