opal 0.7.2 → 0.8.0.beta1

data/opal/corelib/array/inheritance.rb

@@ -16,6 +16,8 @@ class Array
 end
 
 class Array::Wrapper
+  `def.$$is_array = true`
+
   def self.allocate(array = [])
     obj = super()
     `obj.literal = array`
@@ -74,6 +76,10 @@ class Array::Wrapper
     @literal.inspect
   end
 
+  def hash
+    @literal.hash
+  end
+
   # wrapped results
   def *(other)
     %x{
@@ -110,4 +116,12 @@ class Array::Wrapper
   def flatten(level = undefined)
     self.class.allocate(@literal.flatten(level))
   end
+
+  def -(other)
+    @literal - other
+  end
+
+  def +(other)
+    @literal + other
+  end
 end

data/opal/corelib/boolean.rb

@@ -1,6 +1,11 @@
 class Boolean
   `def.$$is_boolean = true`
 
+  def __id__
+    `self.valueOf() ? 2 : 0`
+  end
+  alias object_id __id__
+
   class << self
     undef_method :new
   end

data/opal/corelib/hash.rb

@@ -423,7 +423,7 @@ class Hash
         return defaults;
       }
 
-      #{ raise KeyError, "key not found" };
+      #{ raise KeyError, "key not found: #{key.inspect}" };
     }
   end
 

data/opal/corelib/kernel.rb

@@ -8,12 +8,14 @@ module Kernel
   end
 
   def ===(other)
-    self == other
+    self.object_id == other.object_id || self == other
   end
 
   def <=>(other)
     %x{
-      if (#{self == other}) {
+      var x = #{self == other};
+
+      if (x && x !== nil) {
         return 0;
       }
 
@@ -54,20 +56,25 @@ module Kernel
     }
   end
 
-  def Array(object, *args, &block)
+  def Array(object)
     %x{
-      if (object == null || object === nil) {
+      var coerced;
+
+      if (object === nil) {
         return [];
       }
-      else if (#{object.respond_to? :to_ary}) {
-        return #{object.to_ary};
-      }
-      else if (#{object.respond_to? :to_a}) {
-        return #{object.to_a};
-      }
-      else {
-        return [object];
+
+      if (object.$$is_array) {
+        return object;
       }
+
+      coerced = #{Opal.coerce_to?(object, Array, :to_ary)};
+      if (coerced !== nil) { return coerced; }
+
+      coerced = #{Opal.coerce_to?(object, Array, :to_a)};
+      if (coerced !== nil) { return coerced; }
+
+      return [object];
     }
   end
 
@@ -171,132 +178,544 @@ module Kernel
     self
   end
 
-  def format(format, *args)
+  def format(format_string, *args)
+    if args.length == 1 && args[0].respond_to?(:to_ary)
+      args = args[0].to_ary
+      args = args.to_a
+    end
+
     %x{
-      var idx = 0;
-      return format.replace(/%(\d+\$)?([-+ 0]*)(\d*|\*(\d+\$)?)(?:\.(\d*|\*(\d+\$)?))?([cspdiubBoxXfgeEG])|(%%)/g, function(str, idx_str, flags, width_str, w_idx_str, prec_str, p_idx_str, spec, escaped) {
-        if (escaped) {
-          return '%';
+      var result = '',
+          //used for slicing:
+          begin_slice = 0,
+          end_slice,
+          //used for iterating over the format string:
+          i,
+          len = format_string.length,
+          //used for processing field values:
+          arg,
+          str,
+          //used for processing %g and %G fields:
+          exponent,
+          //used for keeping track of width and precision:
+          width,
+          precision,
+          //used for holding temporary values:
+          tmp_num,
+          //used for processing %{} and %<> fileds:
+          hash_parameter_key,
+          closing_brace_char,
+          //used for processing %b, %B, %o, %x, and %X fields:
+          base_number,
+          base_prefix,
+          base_neg_zero_regex,
+          base_neg_zero_digit,
+          //used for processing arguments:
+          next_arg,
+          seq_arg_num = 1,
+          pos_arg_num = 0,
+          //used for keeping track of flags:
+          flags,
+          FNONE  = 0,
+          FSHARP = 1,
+          FMINUS = 2,
+          FPLUS  = 4,
+          FZERO  = 8,
+          FSPACE = 16,
+          FWIDTH = 32,
+          FPREC  = 64,
+          FPREC0 = 128;
+
+      function CHECK_FOR_FLAGS() {
+        if (flags&FWIDTH) { #{raise ArgumentError, 'flag after width'} }
+        if (flags&FPREC0) { #{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'} }
+      }
+
+      function GET_NTH_ARG(num) {
+        if (num >= args.length) { #{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"}
+        case -2: #{raise ArgumentError, "unnumbered(#{`seq_arg_num`}) mixed with named"}
         }
+        pos_arg_num = seq_arg_num++;
+        return GET_NTH_ARG(pos_arg_num - 1);
+      }
 
-        var width,
-        prec,
-        is_integer_spec = ("diubBoxX".indexOf(spec) != -1),
-        is_float_spec = ("eEfgG".indexOf(spec) != -1),
-        prefix = '',
-        obj;
-
-        if (width_str === undefined) {
-          width = undefined;
-        } else if (width_str.charAt(0) == '*') {
-          var w_idx = idx++;
-          if (w_idx_str) {
-            w_idx = parseInt(w_idx_str, 10) - 1;
-          }
-          width = #{`args[w_idx]`.to_i};
-        } else {
-          width = parseInt(width_str, 10);
+      function GET_POS_ARG(num) {
+        if (pos_arg_num > 0) {
+          #{raise ArgumentError, "numbered(#{`num`}) after unnumbered(#{`pos_arg_num`})"}
         }
-        if (!prec_str) {
-          prec = is_float_spec ? 6 : undefined;
-        } else if (prec_str.charAt(0) == '*') {
-          var p_idx = idx++;
-          if (p_idx_str) {
-            p_idx = parseInt(p_idx_str, 10) - 1;
-          }
-          prec = #{`args[p_idx]`.to_i};
-        } else {
-          prec = parseInt(prec_str, 10);
+        if (pos_arg_num === -2) {
+          #{raise ArgumentError, "numbered(#{`num`}) after named"}
         }
-        if (idx_str) {
-          idx = parseInt(idx_str, 10) - 1;
+        if (num < 1) {
+          #{raise ArgumentError, "invalid index - #{`num`}$"}
         }
-        switch (spec) {
-        case 'c':
-          obj = args[idx];
-          if (obj.$$is_string) {
-            str = obj.charAt(0);
-          } else {
-            str = String.fromCharCode(#{`obj`.to_i});
-          }
-          break;
-        case 's':
-          str = #{`args[idx]`.to_s};
-          if (prec !== undefined) {
-            str = str.substr(0, prec);
-          }
-          break;
-        case 'p':
-          str = #{`args[idx]`.inspect};
-          if (prec !== undefined) {
-            str = str.substr(0, prec);
+        pos_arg_num = -1;
+        return GET_NTH_ARG(num - 1);
+      }
+
+      function GET_ARG() {
+        return (next_arg === undefined ? GET_NEXT_ARG() : next_arg);
+      }
+
+      function READ_NUM(label) {
+        var num, str = '';
+        for (;; i++) {
+          if (i === len) {
+            #{raise ArgumentError, 'malformed format string - %*[0-9]'}
           }
-          break;
-        case 'd':
-        case 'i':
-        case 'u':
-          str = #{`args[idx]`.to_i}.toString();
-          break;
-        case 'b':
-        case 'B':
-          str = #{`args[idx]`.to_i}.toString(2);
-          break;
-        case 'o':
-          str = #{`args[idx]`.to_i}.toString(8);
-          break;
-        case 'x':
-        case 'X':
-          str = #{`args[idx]`.to_i}.toString(16);
-          break;
-        case 'e':
-        case 'E':
-          str = #{`args[idx]`.to_f}.toExponential(prec);
-          break;
-        case 'f':
-          str = #{`args[idx]`.to_f}.toFixed(prec);
-          break;
-        case 'g':
-        case 'G':
-          str = #{`args[idx]`.to_f}.toPrecision(prec);
-          break;
-        }
-        idx++;
-        if (is_integer_spec || is_float_spec) {
-          if (str.charAt(0) == '-') {
-            prefix = '-';
-            str = str.substr(1);
-          } else {
-            if (flags.indexOf('+') != -1) {
-              prefix = '+';
-            } else if (flags.indexOf(' ') != -1) {
-              prefix = ' ';
+          if (format_string.charCodeAt(i) < 48 || format_string.charCodeAt(i) > 57) {
+            i--;
+            num = parseInt(str) || 0;
+            if (num > 2147483647) {
+              #{raise ArgumentError, "#{`label`} too big"}
             }
+            return num;
           }
+          str += format_string.charAt(i);
         }
-        if (is_integer_spec && prec !== undefined) {
-          if (str.length < prec) {
-            str = #{'0' * `prec - str.length`} + str;
-          }
+      }
+
+      function READ_NUM_AFTER_ASTER(label) {
+        var arg, num = READ_NUM(label);
+        if (format_string.charAt(i + 1) === '$') {
+          i++;
+          arg = GET_POS_ARG(num);
+        } else {
+          arg = GET_NEXT_ARG();
         }
-        var total_len = prefix.length + str.length;
-        if (width !== undefined && total_len < width) {
-          if (flags.indexOf('-') != -1) {
-            str = str + #{' ' * `width - total_len`};
-          } else {
-            var pad_char = ' ';
-            if (flags.indexOf('0') != -1) {
-              str = #{'0' * `width - total_len`} + str;
+        return #{`arg`.to_int};
+      }
+
+      for (i = format_string.indexOf('%'); i !== -1; i = format_string.indexOf('%', i)) {
+        str = undefined;
+
+        flags = FNONE;
+        width = -1;
+        precision = -1;
+        next_arg = undefined;
+
+        end_slice = i;
+
+        i++;
+
+        switch (format_string.charAt(i)) {
+        case '%':
+          begin_slice = i;
+        case '':
+        case '\n':
+        case '\0':
+          i++;
+          continue;
+        }
+
+        format_sequence: for (; i < len; i++) {
+          switch (format_string.charAt(i)) {
+
+          case ' ':
+            CHECK_FOR_FLAGS();
+            flags |= FSPACE;
+            continue format_sequence;
+
+          case '#':
+            CHECK_FOR_FLAGS();
+            flags |= FSHARP;
+            continue format_sequence;
+
+          case '+':
+            CHECK_FOR_FLAGS();
+            flags |= FPLUS;
+            continue format_sequence;
+
+          case '-':
+            CHECK_FOR_FLAGS();
+            flags |= FMINUS;
+            continue format_sequence;
+
+          case '0':
+            CHECK_FOR_FLAGS();
+            flags |= FZERO;
+            continue format_sequence;
+
+          case '1':
+          case '2':
+          case '3':
+          case '4':
+          case '5':
+          case '6':
+          case '7':
+          case '8':
+          case '9':
+            tmp_num = READ_NUM('width');
+            if (format_string.charAt(i + 1) === '$') {
+              if (i + 2 === len) {
+                str = '%';
+                i++;
+                break format_sequence;
+              }
+              if (next_arg !== undefined) {
+                #{raise ArgumentError, "value given twice - %#{`tmp_num`}$"}
+              }
+              next_arg = GET_POS_ARG(tmp_num);
+              i++;
+            } else {
+              CHECK_FOR_WIDTH();
+              flags |= FWIDTH;
+              width = tmp_num;
+            }
+            continue format_sequence;
+
+          case '<':
+          case '\{':
+            closing_brace_char = (format_string.charAt(i) === '<' ? '>' : '\}');
+            hash_parameter_key = '';
+
+            i++;
+
+            for (;; i++) {
+              if (i === len) {
+                #{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`})"}
+                }
+                if (pos_arg_num === -1) {
+                  #{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'}
+                }
+
+                next_arg = #{`args[0]`.fetch(`hash_parameter_key`)};
+
+                if (closing_brace_char === '>') {
+                  continue format_sequence;
+                } else {
+                  str = next_arg.toString();
+                  if (precision !== -1) { str = str.slice(0, precision); }
+                  if (flags&FMINUS) {
+                    while (str.length < width) { str = str + ' '; }
+                  } else {
+                    while (str.length < width) { str = ' ' + str; }
+                  }
+                  break format_sequence;
+                }
+              }
+              hash_parameter_key += format_string.charAt(i);
+            }
+
+          case '*':
+            i++;
+            CHECK_FOR_WIDTH();
+            flags |= FWIDTH;
+            width = READ_NUM_AFTER_ASTER('width');
+            if (width < 0) {
+              flags |= FMINUS;
+              width = -width;
+            }
+            continue format_sequence;
+
+          case '.':
+            if (flags&FPREC0) {
+              #{raise ArgumentError, 'precision given twice'}
+            }
+            flags |= FPREC|FPREC0;
+            precision = 0;
+            i++;
+            if (format_string.charAt(i) === '*') {
+              i++;
+              precision = READ_NUM_AFTER_ASTER('precision');
+              if (precision < 0) {
+                flags &= ~FPREC;
+              }
+              continue format_sequence;
+            }
+            precision = READ_NUM('precision');
+            continue format_sequence;
+
+          case 'd':
+          case 'i':
+          case 'u':
+            arg = #{Integer(`GET_ARG()`)};
+            if (arg >= 0) {
+              str = arg.toString();
+              while (str.length < precision) { str = '0' + str; }
+              if (flags&FMINUS) {
+                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                while (str.length < width) { str = str + ' '; }
+              } else {
+                if (flags&FZERO && precision === -1) {
+                  while (str.length < width - ((flags&FPLUS || flags&FSPACE) ? 1 : 0)) { str = '0' + str; }
+                  if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                } else {
+                  if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                  while (str.length < width) { str = ' ' + str; }
+                }
+              }
+            } else {
+              str = (-arg).toString();
+              while (str.length < precision) { str = '0' + str; }
+              if (flags&FMINUS) {
+                str = '-' + str;
+                while (str.length < width) { str = str + ' '; }
+              } else {
+                if (flags&FZERO && precision === -1) {
+                  while (str.length < width - 1) { str = '0' + str; }
+                  str = '-' + str;
+                } else {
+                  str = '-' + str;
+                  while (str.length < width) { str = ' ' + str; }
+                }
+              }
+            }
+            break format_sequence;
+
+          case 'b':
+          case 'B':
+          case 'o':
+          case 'x':
+          case 'X':
+            switch (format_string.charAt(i)) {
+            case 'b':
+            case 'B':
+              base_number = 2;
+              base_prefix = '0b';
+              base_neg_zero_regex = /^1+/;
+              base_neg_zero_digit = '1';
+              break;
+            case 'o':
+              base_number = 8;
+              base_prefix = '0';
+              base_neg_zero_regex = /^3?7+/;
+              base_neg_zero_digit = '7';
+              break;
+            case 'x':
+            case 'X':
+              base_number = 16;
+              base_prefix = '0x';
+              base_neg_zero_regex = /^f+/;
+              base_neg_zero_digit = 'f';
+              break;
+            }
+            arg = #{Integer(`GET_ARG()`)};
+            if (arg >= 0) {
+              str = arg.toString(base_number);
+              while (str.length < precision) { str = '0' + str; }
+              if (flags&FMINUS) {
+                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                if (flags&FSHARP && arg !== 0) { str = base_prefix + str; }
+                while (str.length < width) { str = str + ' '; }
+              } else {
+                if (flags&FZERO && precision === -1) {
+                  while (str.length < width - ((flags&FPLUS || flags&FSPACE) ? 1 : 0) - ((flags&FSHARP && arg !== 0) ? base_prefix.length : 0)) { str = '0' + str; }
+                  if (flags&FSHARP && arg !== 0) { str = base_prefix + str; }
+                  if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                } else {
+                  if (flags&FSHARP && arg !== 0) { str = base_prefix + str; }
+                  if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                  while (str.length < width) { str = ' ' + str; }
+                }
+              }
+            } else {
+              if (flags&FPLUS || flags&FSPACE) {
+                str = (-arg).toString(base_number);
+                while (str.length < precision) { str = '0' + str; }
+                if (flags&FMINUS) {
+                  if (flags&FSHARP) { str = base_prefix + str; }
+                  str = '-' + str;
+                  while (str.length < width) { str = str + ' '; }
+                } else {
+                  if (flags&FZERO && precision === -1) {
+                    while (str.length < width - 1 - (flags&FSHARP ? 2 : 0)) { str = '0' + str; }
+                    if (flags&FSHARP) { str = base_prefix + str; }
+                    str = '-' + str;
+                  } else {
+                    if (flags&FSHARP) { str = base_prefix + str; }
+                    str = '-' + str;
+                    while (str.length < width) { str = ' ' + str; }
+                  }
+                }
+              } else {
+                str = (arg >>> 0).toString(base_number).replace(base_neg_zero_regex, base_neg_zero_digit);
+                while (str.length < precision - 2) { str = base_neg_zero_digit + str; }
+                if (flags&FMINUS) {
+                  str = '..' + str;
+                  if (flags&FSHARP) { str = base_prefix + str; }
+                  while (str.length < width) { str = str + ' '; }
+                } else {
+                  if (flags&FZERO && precision === -1) {
+                    while (str.length < width - 2 - (flags&FSHARP ? base_prefix.length : 0)) { str = base_neg_zero_digit + str; }
+                    str = '..' + str;
+                    if (flags&FSHARP) { str = base_prefix + str; }
+                  } else {
+                    str = '..' + str;
+                    if (flags&FSHARP) { str = base_prefix + str; }
+                    while (str.length < width) { str = ' ' + str; }
+                  }
+                }
+              }
+            }
+            if (format_string.charAt(i) === format_string.charAt(i).toUpperCase()) {
+              str = str.toUpperCase();
+            }
+            break format_sequence;
+
+          case 'f':
+          case 'e':
+          case 'E':
+          case 'g':
+          case 'G':
+            arg = #{Float(`GET_ARG()`)};
+            if (arg >= 0 || isNaN(arg)) {
+              if (arg === Infinity) {
+                str = 'Inf';
+              } else {
+                switch (format_string.charAt(i)) {
+                case 'f':
+                  str = arg.toFixed(precision === -1 ? 6 : precision);
+                  break;
+                case 'e':
+                case 'E':
+                  str = arg.toExponential(precision === -1 ? 6 : precision);
+                  break;
+                case 'g':
+                case 'G':
+                  str = arg.toExponential();
+                  exponent = parseInt(str.split('e')[1]);
+                  if (!(exponent < -4 || exponent >= (precision === -1 ? 6 : precision))) {
+                    str = arg.toPrecision(precision === -1 ? (flags&FSHARP ? 6 : undefined) : precision);
+                  }
+                  break;
+                }
+              }
+              if (flags&FMINUS) {
+                if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                while (str.length < width) { str = str + ' '; }
+              } else {
+                if (flags&FZERO && arg !== Infinity && !isNaN(arg)) {
+                  while (str.length < width - ((flags&FPLUS || flags&FSPACE) ? 1 : 0)) { str = '0' + str; }
+                  if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                } else {
+                  if (flags&FPLUS || flags&FSPACE) { str = (flags&FPLUS ? '+' : ' ') + str; }
+                  while (str.length < width) { str = ' ' + str; }
+                }
+              }
+            } else {
+              if (arg === -Infinity) {
+                str = 'Inf';
+              } else {
+                switch (format_string.charAt(i)) {
+                case 'f':
+                  str = (-arg).toFixed(precision === -1 ? 6 : precision);
+                  break;
+                case 'e':
+                case 'E':
+                  str = (-arg).toExponential(precision === -1 ? 6 : precision);
+                  break;
+                case 'g':
+                case 'G':
+                  str = (-arg).toExponential();
+                  exponent = parseInt(str.split('e')[1]);
+                  if (!(exponent < -4 || exponent >= (precision === -1 ? 6 : precision))) {
+                    str = (-arg).toPrecision(precision === -1 ? (flags&FSHARP ? 6 : undefined) : precision);
+                  }
+                  break;
+                }
+              }
+              if (flags&FMINUS) {
+                str = '-' + str;
+                while (str.length < width) { str = str + ' '; }
+              } else {
+                if (flags&FZERO && arg !== -Infinity) {
+                  while (str.length < width - 1) { str = '0' + str; }
+                  str = '-' + str;
+                } else {
+                  str = '-' + str;
+                  while (str.length < width) { str = ' ' + str; }
+                }
+              }
+            }
+            if (format_string.charAt(i) === format_string.charAt(i).toUpperCase() && arg !== Infinity && arg !== -Infinity && !isNaN(arg)) {
+              str = str.toUpperCase();
+            }
+            str = str.replace(/([eE][-+]?)([0-9])$/, '$10$2');
+            break format_sequence;
+
+          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'}
+
+          case 'c':
+            arg = GET_ARG();
+            if (#{`arg`.respond_to?(:to_ary)}) { arg = #{`arg`.to_ary}[0]; }
+            if (#{`arg`.respond_to?(:to_str)}) {
+              str = #{`arg`.to_str};
+            } else {
+              str = String.fromCharCode(#{Opal.coerce_to(`arg`, Integer, :to_int)});
+            }
+            if (str.length !== 1) {
+              #{raise ArgumentError, '%c requires a character'}
+            }
+            if (flags&FMINUS) {
+              while (str.length < width) { str = str + ' '; }
+            } else {
+              while (str.length < width) { str = ' ' + str; }
+            }
+            break format_sequence;
+
+          case 'p':
+            str = #{`GET_ARG()`.inspect};
+            if (precision !== -1) { str = str.slice(0, precision); }
+            if (flags&FMINUS) {
+              while (str.length < width) { str = str + ' '; }
             } else {
-              prefix = #{' ' * `width - total_len`} + prefix;
+              while (str.length < width) { str = ' ' + str; }
             }
+            break format_sequence;
+
+          case 's':
+            str = #{`GET_ARG()`.to_s};
+            if (precision !== -1) { str = str.slice(0, precision); }
+            if (flags&FMINUS) {
+              while (str.length < width) { str = str + ' '; }
+            } else {
+              while (str.length < width) { str = ' ' + str; }
+            }
+            break format_sequence;
+
+          default:
+            #{raise ArgumentError, "malformed format string - %#{`format_string.charAt(i)`}"}
           }
         }
-        var result = prefix + str;
-        if ('XEG'.indexOf(spec) != -1) {
-          result = result.toUpperCase();
+
+        if (str === undefined) {
+          #{raise ArgumentError, 'malformed format string - %'}
         }
-        return result;
-      });
+
+        result += format_string.slice(begin_slice, end_slice) + str;
+        begin_slice = i + 1;
+      }
+
+      if (#{$DEBUG} && pos_arg_num >= 0 && seq_arg_num < args.length) {
+        #{raise ArgumentError, 'too many arguments for format string'}
+      }
+
+      return result + format_string.slice(begin_slice);
     }
   end
 
@@ -310,7 +729,7 @@ module Kernel
   end
 
   def hash
-    `[self.$$class.$$name,#{`self.$$class`.__id__},#{__id__}].join(':')`
+    "#{self.class}:#{self.class.__id__}:#{__id__}"
   end
 
   def initialize_copy(other)
@@ -356,52 +775,123 @@ module Kernel
     }
   end
 
-  def Integer(value, base = nil)
-    if String === value
-      if value.empty?
-        raise ArgumentError, "invalid value for Integer: (empty string)"
-      end
+  def Integer(value, base = undefined)
+    %x{
+      var i, str, base_digits;
 
-      return `parseInt(#{value}, #{base || `undefined`})`
-    end
+      if (!value.$$is_string) {
+        if (base !== undefined) {
+          #{raise ArgumentError, "base specified for non string value"}
+        }
+        if (value === nil) {
+          #{raise TypeError, "can't convert nil into Integer"}
+        }
+        if (value.$$is_number) {
+          if (value === Infinity || value === -Infinity || isNaN(value)) {
+            #{raise FloatDomainError, value}
+          }
+          return Math.floor(value);
+        }
+        if (#{value.respond_to?(:to_int)}) {
+          i = #{value.to_int};
+          if (i !== nil) {
+            return i;
+          }
+        }
+        return #{Opal.coerce_to!(value, Integer, :to_i)};
+      }
 
-    if base
-      raise ArgumentError "base is only valid for String values"
-    end
+      if (base === undefined) {
+        base = 0;
+      } else {
+        base = #{Opal.coerce_to(`base`, Integer, :to_int)};
+        if (base === 1 || base < 0 || base > 36) {
+          #{raise ArgumentError, "invalid radix #{base}"}
+        }
+      }
+
+      str = value.toLowerCase();
+
+      str = str.replace(/(\d)_(?=\d)/g, '$1');
+
+      str = str.replace(/^(\s*[+-]?)(0[bodx]?)/, function (_, head, flag) {
+        switch (flag) {
+        case '0b':
+          if (base === 0 || base === 2) {
+            base = 2;
+            return head;
+          }
+        case '0':
+        case '0o':
+          if (base === 0 || base === 8) {
+            base = 8;
+            return head;
+          }
+        case '0d':
+          if (base === 0 || base === 10) {
+            base = 10;
+            return head;
+          }
+        case '0x':
+          if (base === 0 || base === 16) {
+            base = 16;
+            return head;
+          }
+        }
+        #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
+      });
 
-    case value
-    when Integer
-      value
+      base = (base === 0 ? 10 : base);
 
-    when Float
-      if value.nan? or value.infinite?
-        raise FloatDomainError, "unable to coerce #{value} to Integer"
-      end
+      base_digits = '0-' + (base <= 10 ? base - 1 : '9a-' + String.fromCharCode(97 + (base - 11)));
 
-      value.to_int
+      if (!(new RegExp('^\\s*[+-]?[' + base_digits + ']+\\s*$')).test(str)) {
+        #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
+      }
 
-    when NilClass
-      raise TypeError, "can't convert nil into Integer"
+      i = parseInt(str, base);
 
-    else
-      if value.respond_to? :to_int
-        value.to_int
-      elsif value.respond_to? :to_i
-        value.to_i
-      else
-        raise TypeError, "can't convert #{value.class} into Integer"
-      end
-    end
+      if (isNaN(i)) {
+        #{raise ArgumentError, "invalid value for Integer(): \"#{value}\""}
+      }
+
+      return i;
+    }
   end
 
   def Float(value)
-    if String === value
-      `parseFloat(value)`
-    elsif value.respond_to? :to_f
-      value.to_f
-    else
-      raise TypeError, "can't convert #{value.class} into Float"
-    end
+    %x{
+      var str;
+
+      if (value === nil) {
+        #{raise TypeError, "can't convert nil into Float"}
+      }
+
+      if (value.$$is_string) {
+        str = value.toString();
+
+        str = str.replace(/(\d)_(?=\d)/g, '$1');
+
+        //Special case for hex strings only:
+        if (/^\s*[-+]?0[xX][0-9a-fA-F]+\s*$/.test(str)) {
+          return #{Integer(`str`)};
+        }
+
+        if (!/^\s*[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\s*$/.test(str)) {
+          #{raise ArgumentError, "invalid value for Float(): \"#{value}\""}
+        }
+
+        return parseFloat(str);
+      }
+
+      return #{Opal.coerce_to!(value, Float, :to_f)};
+    }
+  end
+
+  def Hash(arg)
+    return {} if arg.nil? || arg == []
+    return arg if Hash === arg
+    return Opal.coerce_to!(arg, Hash, :to_hash)
   end
 
   def is_a?(klass)
@@ -482,16 +972,21 @@ module Kernel
   def raise(exception = undefined, string = undefined)
     %x{
       if (exception == null && #$!) {
-        exception = #$!;
+        throw #$!;
+      }
+
+      if (exception == null) {
+        exception = #{RuntimeError.new};
       }
       else if (exception.$$is_string) {
         exception = #{RuntimeError.new exception};
       }
-      else if (!#{exception.is_a? Exception}) {
+      else if (exception.$$is_class) {
         exception = #{exception.new string};
       }
 
-      #{$! = exception};
+      #$! = exception;
+
       throw exception;
     }
   end
@@ -564,7 +1059,7 @@ module Kernel
   alias public_send __send__
 
   def singleton_class
-    %x{Opal.get_singleton_class(self)}
+    `Opal.get_singleton_class(self)`
   end
 
   alias sprintf format
@@ -572,7 +1067,8 @@ module Kernel
   alias srand rand
 
   def String(str)
-    `String(str)`
+    Opal.coerce_to?(str, String, :to_str) ||
+      Opal.coerce_to!(str, String, :to_s)
   end
 
   def taint