opal 0.11.4 → 1.0.0.beta1

data/opal/corelib/hash.rb

@@ -12,7 +12,7 @@ class Hash
   include Enumerable
 
   # Mark all hash instances as valid hashes (used to check keyword args, etc)
-  `def.$$is_hash = true`
+  `self.$$prototype.$$is_hash = true`
 
   def self.[](*argv)
     %x{
@@ -65,7 +65,7 @@ class Hash
 
   def self.allocate
     %x{
-      var hash = new self.$$alloc();
+      var hash = new self.$$constructor();
 
       Opal.hash_init(hash);
 
@@ -87,8 +87,9 @@ class Hash
       }
       self.$$none = (defaults === undefined ? nil : defaults);
       self.$$proc = block;
+
+      return self;
     }
-    self
   end
 
   def ==(other)
@@ -220,7 +221,7 @@ class Hash
 
   def clone
     %x{
-      var hash = new self.$$class.$$alloc();
+      var hash = new self.$$class();
 
       Opal.hash_init(hash);
       Opal.hash_clone(self, hash);
@@ -365,7 +366,7 @@ class Hash
       }
 
       if (block !== nil) {
-        return #{block.call(key)};
+        return #{yield key};
       }
 
       return nil;
@@ -373,7 +374,7 @@ class Hash
   end
 
   def delete_if(&block)
-    return enum_for(:delete_if){self.size} unless block
+    return enum_for(:delete_if) { size } unless block
 
     %x{
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
@@ -419,7 +420,7 @@ class Hash
   end
 
   def each(&block)
-    return enum_for(:each){self.size} unless block
+    return enum_for(:each) { size } unless block
 
     %x{
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
@@ -440,7 +441,7 @@ class Hash
   end
 
   def each_key(&block)
-    return enum_for(:each_key){self.size} unless block
+    return enum_for(:each_key) { size } unless block
 
     %x{
       for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
@@ -456,7 +457,7 @@ class Hash
   alias each_pair each
 
   def each_value(&block)
-    return enum_for(:each_value){self.size} unless block
+    return enum_for(:each_value) { size } unless block
 
     %x{
       for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
@@ -492,7 +493,7 @@ class Hash
       }
     }
 
-    raise KeyError, "key not found: #{key.inspect}"
+    raise KeyError.new("key not found: #{key.inspect}", key: key, receiver: self)
   end
 
   def fetch_values(*keys, &block)
@@ -642,7 +643,7 @@ class Hash
 
   alias indices indexes
 
-  `var inspect_ids;`
+  `var inspect_ids`
 
   def inspect
     %x{
@@ -706,7 +707,7 @@ class Hash
   end
 
   def keep_if(&block)
-    return enum_for(:keep_if){self.size} unless block
+    return enum_for(:keep_if) { size } unless block
 
     %x{
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
@@ -843,7 +844,7 @@ class Hash
   end
 
   def reject(&block)
-    return enum_for(:reject){self.size} unless block
+    return enum_for(:reject) { size } unless block
 
     %x{
       var hash = Opal.hash();
@@ -870,7 +871,7 @@ class Hash
   end
 
   def reject!(&block)
-    return enum_for(:reject!){self.size} unless block
+    return enum_for(:reject!) { size } unless block
 
     %x{
       var changes_were_made = false;
@@ -930,7 +931,7 @@ class Hash
   end
 
   def select(&block)
-    return enum_for(:select){self.size} unless block
+    return enum_for(:select) { size } unless block
 
     %x{
       var hash = Opal.hash();
@@ -957,7 +958,7 @@ class Hash
   end
 
   def select!(&block)
-    return enum_for(:select!){self.size} unless block
+    return enum_for(:select!) { size } unless block
 
     %x{
       var result = nil;
@@ -1006,7 +1007,23 @@ class Hash
 
   alias size length
 
-  alias_method :store, :[]=
+  def slice(*keys)
+    %x{
+      var result = Opal.hash();
+
+      for (var i = 0, length = keys.length; i < length; i++) {
+        var key = keys[i], value = Opal.hash_get(self, key);
+
+        if (value !== undefined) {
+          Opal.hash_put(result, key, value);
+        }
+      }
+
+      return result;
+    }
+  end
+
+  alias store []=
 
   def to_a
     %x{
@@ -1035,7 +1052,7 @@ class Hash
         return self;
       }
 
-      var hash = new Opal.Hash.$$alloc();
+      var hash = new Opal.Hash();
 
       Opal.hash_init(hash);
       Opal.hash_clone(self, hash);
@@ -1052,7 +1069,7 @@ class Hash
     proc do |key = undefined|
       %x{
         if (key == null) {
-          #{raise ArgumentError, "no key given"}
+          #{raise ArgumentError, 'no key given'}
         }
       }
 
@@ -1062,8 +1079,60 @@ class Hash
 
   alias to_s inspect
 
+  def transform_keys(&block)
+    return enum_for(:transform_keys) { size } unless block
+
+    %x{
+      var result = Opal.hash();
+
+      for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        key = Opal.yield1(block, key);
+
+        Opal.hash_put(result, key, value);
+      }
+
+      return result;
+    }
+  end
+
+  def transform_keys!(&block)
+    return enum_for(:transform_keys!) { size } unless block
+
+    %x{
+      var keys = Opal.slice.call(self.$$keys),
+          i, length = keys.length, key, value, new_key;
+
+      for (i = 0; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          value = self.$$smap[key];
+        } else {
+          value = key.value;
+          key = key.key;
+        }
+
+        new_key = Opal.yield1(block, key);
+
+        Opal.hash_delete(self, key);
+        Opal.hash_put(self, new_key, value);
+      }
+
+      return self;
+    }
+  end
+
   def transform_values(&block)
-    return enum_for(:transform_values){self.size} unless block
+    return enum_for(:transform_values) { size } unless block
 
     %x{
       var result = Opal.hash();
@@ -1088,7 +1157,7 @@ class Hash
   end
 
   def transform_values!(&block)
-    return enum_for(:transform_values!){self.size} unless block
+    return enum_for(:transform_values!) { size } unless block
 
     %x{
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {

data/opal/corelib/helpers.rb

@@ -1,11 +1,11 @@
 module Opal
-  def self.bridge(klass, constructor)
-    `Opal.bridge(klass, constructor)`
+  def self.bridge(constructor, klass)
+    `Opal.bridge(constructor, klass)`
   end
 
   def self.type_error(object, type, method = nil, coerced = nil)
     if method && coerced
-      TypeError.new "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
+      TypeError.new "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class})"
     else
       TypeError.new "no implicit conversion of #{object.class} into #{type}"
     end
@@ -80,14 +80,14 @@ module Opal
     }
   end
 
-  def self.respond_to?(obj, method)
+  def self.respond_to?(obj, method, include_all = false)
     %x{
       if (obj == null || !obj.$$class) {
         return false;
       }
     }
 
-    obj.respond_to? method
+    obj.respond_to?(method, include_all)
   end
 
   def self.inspect_obj(obj)
@@ -155,7 +155,8 @@ module Opal
       var method_name, method;
       for (var i = method_names.length - 1; i >= 0; i--) {
         method_name = method_names[i];
-        method = owner_class.$$proto['$'+method_name];
+        method = owner_class.$$prototype['$'+method_name];
+
         if (method && !method.$$stub) {
           method.$$pristine = true;
         }

data/opal/corelib/kernel.rb

@@ -8,11 +8,11 @@ module Kernel
   end
 
   def !~(obj)
-    not(self =~ obj)
+    !(self =~ obj)
   end
 
   def ===(other)
-    self.object_id == other.object_id || self == other
+    object_id == other.object_id || self == other
   end
 
   def <=>(other)
@@ -44,26 +44,23 @@ module Kernel
 
   def methods(all = true)
     %x{
-      var methods = [];
-
-      for (var key in self) {
-        if (key[0] == "$" && typeof(self[key]) === "function") {
-          if (all == false || all === nil) {
-            if (!Opal.hasOwnProperty.call(self, key)) {
-              continue;
-            }
-          }
-          if (self[key].$$stub === undefined) {
-            methods.push(key.substr(1));
-          }
-        }
+      if (#{Opal.truthy?(all)}) {
+        return Opal.methods(self);
+      } else {
+        return Opal.own_methods(self);
       }
-
-      return methods;
     }
   end
 
-  alias public_methods methods
+  def public_methods(all = true)
+    %x{
+      if (#{Opal.truthy?(all)}) {
+        return Opal.methods(self);
+      } else {
+        return Opal.receiver_methods(self);
+      }
+    }
+  end
 
   def Array(object)
     %x{
@@ -116,20 +113,29 @@ module Kernel
 
   def copy_singleton_methods(other)
     %x{
-      var name;
+      var i, name, names, length;
 
       if (other.hasOwnProperty('$$meta')) {
-        var other_singleton_class_proto = Opal.get_singleton_class(other).$$proto;
-        var self_singleton_class_proto = Opal.get_singleton_class(self).$$proto;
-
-        for (name in other_singleton_class_proto) {
-          if (name.charAt(0) === '$' && other_singleton_class_proto.hasOwnProperty(name)) {
-            self_singleton_class_proto[name] = other_singleton_class_proto[name];
+        var other_singleton_class = Opal.get_singleton_class(other);
+        var self_singleton_class = Opal.get_singleton_class(self);
+        names = Object.getOwnPropertyNames(other_singleton_class.$$prototype);
+
+        for (i = 0, length = names.length; i < length; i++) {
+          name = names[i];
+          if (Opal.is_method(name)) {
+            self_singleton_class.$$prototype[name] = other_singleton_class.$$prototype[name];
           }
         }
+
+        self_singleton_class.$$const = Object.assign({}, other_singleton_class.$$const);
+        Object.setPrototypeOf(
+          self_singleton_class.$$prototype,
+          Object.getPrototypeOf(other_singleton_class.$$prototype)
+        );
       }
 
-      for (name in other) {
+      for (i = 0, names = Object.getOwnPropertyNames(other), length = names.length; i < length; i++) {
+        name = names[i];
         if (name.charAt(0) === '$' && name.charAt(1) !== '$' && other.hasOwnProperty(name)) {
           self[name] = other[name];
         }
@@ -181,7 +187,7 @@ module Kernel
   def exit(status = true)
     $__at_exit__ ||= []
 
-    while $__at_exit__.size > 0
+    until $__at_exit__.empty?
       block = $__at_exit__.pop
       block.call
     end
@@ -210,6 +216,7 @@ module Kernel
         }
 
         #{`mod`.append_features `singleton`};
+        #{`mod`.extend_object self};
         #{`mod`.extended self};
       }
     }
@@ -217,547 +224,6 @@ module Kernel
     self
   end
 
-  def format(format_string, *args)
-    if args.length == 1 && args[0].respond_to?(:to_ary)
-      ary = Opal.coerce_to?(args[0], Array, :to_ary)
-      args = ary.to_a unless ary.nil?
-    end
-
-    %x{
-      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);
-      }
-
-      function GET_POS_ARG(num) {
-        if (pos_arg_num > 0) {
-          #{raise ArgumentError, "numbered(#{`num`}) after unnumbered(#{`pos_arg_num`})"}
-        }
-        if (pos_arg_num === -2) {
-          #{raise ArgumentError, "numbered(#{`num`}) after named"}
-        }
-        if (num < 1) {
-          #{raise ArgumentError, "invalid index - #{`num`}$"}
-        }
-        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]'}
-          }
-          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"}
-            }
-            return num;
-          }
-          str += format_string.charAt(i);
-        }
-      }
-
-      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();
-        }
-        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], 10);
-                  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], 10);
-                  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 {
-              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)`}"}
-          }
-        }
-
-        if (str === undefined) {
-          #{raise ArgumentError, 'malformed format string - %'}
-        }
-
-        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
-
   def hash
     __id__
   end
@@ -842,7 +308,7 @@ module Kernel
 
       if (!value.$$is_string) {
         if (base !== undefined) {
-          #{raise ArgumentError, "base specified for non string value"}
+          #{raise ArgumentError, 'base specified for non string value'}
         }
         if (value === nil) {
           #{raise TypeError, "can't convert nil into Integer"}
@@ -956,7 +422,7 @@ module Kernel
   def Hash(arg)
     return {} if arg.nil? || arg == []
     return arg if Hash === arg
-    return Opal.coerce_to!(arg, Hash, :to_hash)
+    Opal.coerce_to!(arg, Hash, :to_hash)
   end
 
   def is_a?(klass)
@@ -976,9 +442,7 @@ module Kernel
   alias kind_of? is_a?
 
   def lambda(&block)
-    `block.$$is_lambda = true`
-
-    block
+    `Opal.lambda(block)`
   end
 
   def load(file)
@@ -989,7 +453,7 @@ module Kernel
   def loop
     return enum_for(:loop) { Float::INFINITY } unless block_given?
 
-    while true do
+    while true
       begin
         yield
       rescue StopIteration => e
@@ -1007,7 +471,7 @@ module Kernel
   alias object_id __id__
 
   def printf(*args)
-    if args.length > 0
+    if args.any?
       print format(*args)
     end
 
@@ -1016,7 +480,7 @@ module Kernel
 
   def proc(&block)
     unless block
-      raise ArgumentError, "tried to create Proc object without a block"
+      raise ArgumentError, 'tried to create Proc object without a block'
     end
 
     `block.$$is_lambda = false`
@@ -1043,8 +507,8 @@ module Kernel
 
   def raise(exception = undefined, string = nil, _backtrace = nil)
     %x{
-      if (exception == null && #$! !== nil) {
-        throw #$!;
+      if (exception == null && #{$!} !== nil) {
+        throw #{$!};
       }
       if (exception == null) {
         exception = #{RuntimeError.new};
@@ -1056,18 +520,18 @@ module Kernel
       else if (exception.$$is_class && #{exception.respond_to?(:exception)}) {
         exception = #{exception.exception string};
       }
-      else if (#{exception.kind_of?(Exception)}) {
+      else if (#{exception.is_a?(Exception)}) {
         // exception is fine
       }
       else {
         exception = #{TypeError.new 'exception class/object expected'};
       }
 
-      if (#$! !== nil) {
-        Opal.exceptions.push(#$!);
+      if (#{$!} !== nil) {
+        Opal.exceptions.push(#{$!});
       }
 
-      #$! = exception;
+      #{$!} = exception;
 
       throw exception;
     }
@@ -1162,7 +626,7 @@ module Kernel
         #{raise TypeError, "can't convert #{seconds.class} into time interval"}
       }
       if (seconds < 0) {
-        #{raise ArgumentError, "time interval must be positive"}
+        #{raise ArgumentError, 'time interval must be positive'}
       }
       var get_time = Opal.global.performance ?
         function() {return performance.now()} :
@@ -1174,8 +638,6 @@ module Kernel
     }
   end
 
-  alias sprintf format
-
   def srand(seed = Random.new_seed)
     Random.srand(seed)
   end
@@ -1206,13 +668,18 @@ module Kernel
   end
 
   def throw(*args)
-    raise UncaughtThrowError.new(args)
+    raise UncaughtThrowError, args
   end
 
   # basic implementation of open, delegate to File.open
   def open(*args, &block)
     File.open(*args, &block)
   end
+
+  def yield_self
+    return enum_for(:yield_self) { 1 } unless block_given?
+    yield self
+  end
 end
 
 class Object