opal 0.8.1 → 0.9.0.beta1

data/opal/corelib/constants.rb

@@ -0,0 +1,9 @@
+RUBY_PLATFORM       = 'opal'
+RUBY_ENGINE         = 'opal'
+RUBY_VERSION        = '2.1.5'
+RUBY_ENGINE_VERSION = '0.9.0.beta1'
+RUBY_RELEASE_DATE   = '2015-10-19'
+RUBY_PATCHLEVEL     = 0
+RUBY_REVISION       = 0
+RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2015 Adam Beynon'
+RUBY_DESCRIPTION    = "opal #{RUBY_ENGINE_VERSION} (#{RUBY_RELEASE_DATE} revision #{RUBY_REVISION})"

data/opal/corelib/enumerable.rb

@@ -67,12 +67,57 @@ module Enumerable
     }
   end
 
-  def chunk(state = undefined, &block)
-    raise NotImplementedError
+  def chunk(state = undefined, &original_block)
+    Kernel.raise ArgumentError, "no block given" unless original_block
+
+    ::Enumerator.new do |yielder|
+      %x{
+        var block, previous = nil, accumulate = [];
+
+        if (state == undefined || state === nil) {
+          block = original_block;
+        } else {
+          block = #{Proc.new { |val| original_block.yield(val, state.dup)}}
+        }
+
+        function releaseAccumulate() {
+          if (accumulate.length > 0) {
+            #{yielder.yield(`previous`, `accumulate`)}
+          }
+        }
+
+        self.$each.$$p = function(value) {
+          var key = Opal.yield1(block, value);
+
+          if (key === $breaker) {
+            return $breaker;
+          }
+
+          if (key === nil) {
+            releaseAccumulate();
+            accumulate = [];
+            previous = nil;
+          } else {
+            if (previous === nil || previous === key) {
+              accumulate.push(value);
+            } else {
+              releaseAccumulate();
+              accumulate = [value];
+            }
+
+            previous = key;
+          }
+        }
+
+        self.$each();
+
+        releaseAccumulate();
+      }
+    end
   end
 
   def collect(&block)
-    return enum_for :collect unless block_given?
+    return enum_for(:collect){self.enumerator_size} unless block_given?
 
     %x{
       var result = [];
@@ -95,7 +140,7 @@ module Enumerable
   end
 
   def collect_concat(&block)
-    return enum_for :collect_concat unless block_given?
+    return enum_for(:collect_concat){self.enumerator_size} unless block_given?
     map { |item| yield item }.flatten(1)
   end
 
@@ -132,7 +177,14 @@ module Enumerable
   end
 
   def cycle(n = nil, &block)
-    return enum_for :cycle, n unless block
+    return enum_for(:cycle, n) {
+      if n == nil
+        respond_to?(:size) ? Float::INFINITY : nil
+      else
+        n = Opal.coerce_to!(n, Integer, :to_int)
+        n > 0 ? self.enumerator_size * n : 0
+      end
+    } unless block_given?
 
     unless n.nil?
       n = Opal.coerce_to! n, Integer, :to_int
@@ -142,7 +194,7 @@ module Enumerable
 
     %x{
       var result,
-          all  = [];
+          all = [], i, length, value;
 
       self.$each.$$p = function() {
         var param = #{Opal.destructure(`arguments`)},
@@ -165,13 +217,11 @@ module Enumerable
       if (all.length === 0) {
         return nil;
       }
-    }
 
-    if n.nil?
-      %x{
+      if (n === nil) {
         while (true) {
-          for (var i = 0, length = all.length; i < length; i++) {
-            var value = Opal.yield1(block, all[i]);
+          for (i = 0, length = all.length; i < length; i++) {
+            value = Opal.yield1(block, all[i]);
 
             if (value === $breaker) {
               return $breaker.$v;
@@ -179,11 +229,10 @@ module Enumerable
           }
         }
       }
-    else
-      %x{
+      else {
         while (n > 1) {
-          for (var i = 0, length = all.length; i < length; i++) {
-            var value = Opal.yield1(block, all[i]);
+          for (i = 0, length = all.length; i < length; i++) {
+            value = Opal.yield1(block, all[i]);
 
             if (value === $breaker) {
               return $breaker.$v;
@@ -193,14 +242,14 @@ module Enumerable
           n--;
         }
       }
-    end
+    }
   end
 
   def detect(ifnone = undefined, &block)
     return enum_for :detect, ifnone unless block_given?
 
     %x{
-      var result = undefined;
+      var result;
 
       self.$each.$$p = function() {
         var params = #{Opal.destructure(`arguments`)},
@@ -306,7 +355,7 @@ module Enumerable
       raise ArgumentError, 'invalid slice size'
     end
 
-    return enum_for :each_slice, n unless block_given?
+    return enum_for(:each_slice, n){respond_to?(:size) ? (size / n).ceil : nil} unless block_given?
 
     %x{
       var result,
@@ -345,7 +394,7 @@ module Enumerable
   end
 
   def each_with_index(*args, &block)
-    return enum_for :each_with_index, *args unless block_given?
+    return enum_for(:each_with_index, *args){self.enumerator_size} unless block_given?
 
     %x{
       var result,
@@ -374,7 +423,7 @@ module Enumerable
   end
 
   def each_with_object(object, &block)
-    return enum_for :each_with_object, object unless block_given?
+    return enum_for(:each_with_object, object){self.enumerator_size} unless block_given?
 
     %x{
       var result;
@@ -416,7 +465,7 @@ module Enumerable
   alias find detect
 
   def find_all(&block)
-    return enum_for :find_all unless block_given?
+    return enum_for(:find_all){self.enumerator_size} unless block_given?
 
     %x{
       var result = [];
@@ -510,8 +559,8 @@ module Enumerable
       end
 
       %x{
-        var current = 0,
-            number  = #{Opal.coerce_to number, Integer, :to_int};
+        var current = 0;
+        number = #{Opal.coerce_to number, Integer, :to_int};
 
         self.$each.$$p = function() {
           result.push(#{Opal.destructure(`arguments`)});
@@ -569,7 +618,7 @@ module Enumerable
   end
 
   def group_by(&block)
-    return enum_for :group_by unless block_given?
+    return enum_for(:group_by){self.enumerator_size} unless block_given?
 
     hash = Hash.new
 
@@ -677,7 +726,6 @@ module Enumerable
   def enumerator_size
     respond_to?(:size) ? size : nil
   end
-  private :enumerator_size
 
   alias map collect
 
@@ -732,7 +780,7 @@ module Enumerable
   end
 
   def max_by(&block)
-    return enum_for :max_by unless block
+    return enum_for(:max_by){self.enumerator_size} unless block
 
     %x{
       var result,
@@ -818,7 +866,7 @@ module Enumerable
   end
 
   def min_by(&block)
-    return enum_for :min_by unless block
+    return enum_for(:min_by){self.enumerator_size} unless block
 
     %x{
       var result,
@@ -940,7 +988,7 @@ module Enumerable
   end
 
   def partition(&block)
-    return enum_for :partition unless block_given?
+    return enum_for(:partition){self.enumerator_size} unless block_given?
 
     %x{
       var truthy = [], falsy = [], result;
@@ -971,7 +1019,7 @@ module Enumerable
   alias reduce inject
 
   def reject(&block)
-    return enum_for :reject unless block_given?
+    return enum_for(:reject){self.enumerator_size} unless block_given?
 
     %x{
       var result = [];
@@ -997,7 +1045,7 @@ module Enumerable
   end
 
   def reverse_each(&block)
-    return enum_for :reverse_each unless block_given?
+    return enum_for(:reverse_each){self.enumerator_size} unless block_given?
 
     %x{
       var result = [];
@@ -1085,13 +1133,14 @@ module Enumerable
   end
 
   def sort_by(&block)
-    return enum_for :sort_by unless block_given?
+    return enum_for(:sort_by){self.enumerator_size} unless block_given?
 
-    map {
+    dup = map {
       arg = Opal.destructure(`arguments`)
-
       [block.call(arg), arg]
-    }.sort { |a, b| a[0] <=> b[0] }.map { |arg| `arg[1]` }
+    }
+    dup.sort! { |a, b| `a[0]` <=> `b[0]` }
+    dup.map! { |i| `i[1]` }
   end
 
   def take(num)

data/opal/corelib/enumerator.rb

@@ -56,7 +56,7 @@ class Enumerator
       offset = 0
     end
 
-    return enum_for :with_index, offset unless block
+    return enum_for(:with_index, offset){self.size} unless block
 
     %x{
       var result, index = offset;
@@ -71,6 +71,8 @@ class Enumerator
         }
 
         index++;
+
+        return value;
       }
 
       self.$each();

data/opal/corelib/error.rb

@@ -1,8 +1,7 @@
-class Exception
-  attr_reader :message
-
-  def self.new(message = 'Exception')
+class Exception < `Error`
+  def self.new(*args)
     %x{
+      var message = (args.length > 0) ? args[0] : nil;
       var err = new self.$$alloc(message);
 
       if (Error.captureStackTrace) {
@@ -10,13 +9,18 @@ class Exception
       }
 
       err.name = self.$$name;
-      err.$initialize(message);
+      err.$initialize.apply(err, args);
       return err;
     }
   end
+  
+  def self.exception(*args)
+    new(*args)
+  end
 
-  def initialize(message)
-    `self.message = message`
+  def initialize(*args)
+    # using self.message aka @message to retain compatibility with native exception's message property
+    `self.message = (args.length > 0) ? args[0] : nil`
   end
 
   def backtrace
@@ -33,12 +37,33 @@ class Exception
       return [];
     }
   end
+  
+  def exception(str=nil)
+    %x{
+      if (str === nil || self === str) {
+        return self;
+      }
+      
+      var cloned = #{self.clone};
+      cloned.message = str;
+      return cloned;
+    }
+  end
+  
+  # not using alias message to_s because you need to be able to override to_s and have message use overridden method, won't work with alias
+  def message
+    to_s
+  end
 
   def inspect
-    "#<#{self.class}: '#@message'>"
+    as_str = to_s
+    as_str.empty? ? self.class.to_s : "#<#{self.class.to_s}: #{to_s}>"
+  end
+  
+  def to_s
+    # using self.message aka @message to retain compatibility with native exception's message property
+    (@message && @message.to_s) || self.class.to_s
   end
-
-  alias to_s message
 end
 
 # keep the indentation, it makes the exception hierarchy clear
@@ -51,8 +76,10 @@ class SystemExit        < Exception; end
 class NoMemoryError     < Exception; end
 class SignalException   < Exception; end
 class Interrupt         < Exception; end
+class SecurityError     < Exception; end
 
 class StandardError     < Exception; end
+class ZeroDivisionError   < StandardError; end
 class NameError           < StandardError; end
 class NoMethodError         < NameError; end
 class RuntimeError        < StandardError; end
@@ -66,6 +93,7 @@ class RangeError          < StandardError; end
 class FloatDomainError      < RangeError; end
 class IOError             < StandardError; end
 class SystemCallError     < StandardError; end
+
 module Errno
   class EINVAL              < SystemCallError
     def self.new
@@ -73,3 +101,14 @@ module Errno
     end
   end
 end
+
+class UncaughtThrowError < ArgumentError
+  attr_reader :sym, :arg
+
+  def initialize(args)
+    @sym = args[0]
+    @arg = args[1] if args.length > 1
+
+    super("uncaught throw #{@sym.inspect}")
+  end
+end

data/opal/corelib/file.rb

@@ -19,6 +19,7 @@ class File < IO
       end
       new_parts.join(SEPARATOR)
     end
+    alias realpath expand_path
 
     def dirname(path)
       split(path)[0..-2]

data/opal/corelib/hash.rb

@@ -8,7 +8,7 @@ class Hash
 
   def self.[](*argv)
     %x{
-      var hash, i, argc = argv.length;
+      var hash, argc = argv.length, i;
 
       if (argc === 1) {
         hash = #{Opal.coerce_to?(argv[0], Hash, :to_hash)};
@@ -57,11 +57,10 @@ class Hash
 
   def self.allocate
     %x{
-      var hash = new self.$$alloc;
+      var hash = new self.$$alloc();
+
+      Opal.hash_init(hash);
 
-      hash.map  = {};
-      hash.smap = {};
-      hash.keys = [];
       hash.none = nil;
       hash.proc = nil;
 
@@ -69,8 +68,15 @@ class Hash
     }
   end
 
+  def self.try_convert(obj)
+    Opal.coerce_to?(obj, Hash, :to_hash)
+  end
+
   def initialize(defaults = undefined, &block)
     %x{
+      if (defaults !== undefined && block !== nil) {
+        #{raise ArgumentError, 'wrong number of arguments (1 for 0)'}
+      }
       self.none = (defaults === undefined ? nil : defaults);
       self.proc = block;
     }
@@ -83,7 +89,7 @@ class Hash
         return true;
       }
 
-      if (!other.keys || !other.smap || !other.map) {
+      if (!other.$$is_hash) {
         return false;
       }
 
@@ -91,30 +97,18 @@ class Hash
         return false;
       }
 
-      var _map  = self.map,
-          smap  = self.smap,
-          _map2 = other.map,
-          smap2 = other.smap,
-          map, map2, key, khash, value, value2;
-
-      for (var i = 0, length = self.keys.length; i < length; i++) {
-        key = self.keys[i];
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, other_value; i < length; i++) {
+        key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map   = smap;
-          map2  = smap2;
+          value = self.smap[key];
+          other_value = other.smap[key];
         } else {
-          khash = key.$hash();
-          map   = _map;
-          map2  = _map2;
+          value = key.value;
+          other_value = Opal.hash_get(other, key.key);
         }
 
-        value  = map[khash];
-        if (value === undefined) console.log('==', key, self);
-        value2 = map2[khash];
-
-        if (value2 === undefined || #{not(`value` == `value2`)}) {
+        if (other_value === undefined || !value['$eql?'](other_value)) {
           return false;
         }
       }
@@ -125,73 +119,36 @@ class Hash
 
   def [](key)
     %x{
-      var map, khash;
-
-      if (key.$$is_string) {
-        map = self.smap;
-        khash = key;
-      } else {
-        map = self.map;
-        khash = key.$hash();
-      }
-
-      if (map === undefined) { console.log(self, '[] --> key:', key, khash, map) }
-
-
-      if (Opal.hasOwnProperty.call(map, khash)) {
-        return map[khash];
-      }
-
-      var proc = #@proc;
+      var value = Opal.hash_get(self, key);
 
-      if (proc !== nil) {
-        return #{ `proc`.call self, key };
+      if (value !== undefined) {
+        return value;
       }
 
-      return #@none;
+      return self.$default(key);
     }
   end
 
   def []=(key, value)
     %x{
-      var map, khash, value;
-
-      if (key.$$is_string) {
-        map = self.smap;
-        khash = key;
-      } else {
-        map = self.map;
-        khash = key.$hash();
-      }
-
-      if (!Opal.hasOwnProperty.call(map, khash)) {
-        self.keys.push(key);
-      }
-
-      map[khash] = value;
-
+      Opal.hash_put(self, key, value);
       return value;
     }
   end
 
   def assoc(object)
     %x{
-      var keys = self.keys,
-          map, key, khash;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key; i < length; i++) {
         key = keys[i];
 
-        if (#{`key` == object}) {
-          if (key.$$is_string) {
-            map = self.smap;
-            khash = key;
-          } else {
-            map = self.map;
-            khash = key.$hash();
+        if (key.$$is_string) {
+          if (#{`key` == object}) {
+            return [key, self.smap[key]];
+          }
+        } else {
+          if (#{`key.key` == object}) {
+            return [key.key, key.value];
           }
-
-          return [key, map[khash]];
         }
       }
 
@@ -201,66 +158,37 @@ class Hash
 
   def clear
     %x{
-      self.map = {};
-      self.smap = {};
-      self.keys = [];
+      Opal.hash_init(self);
       return self;
     }
   end
 
   def clone
     %x{
-      var _map  = {},
-          smap  = {},
-          _map2 = self.map,
-          smap2 = self.smap,
-          keys  = [],
-          map, map2, key, khash, value;
-
-      for (var i = 0, length = self.keys.length; i < length; i++) {
-        key   = self.keys[i];
+      var hash = new self.$$class.$$alloc();
 
-        if (key.$$is_string) {
-          khash = key;
-          map = smap;
-          map2 = smap2;
-        } else {
-          khash = key.$hash();
-          map = _map;
-          map2 = _map2;
-        }
+      Opal.hash_init(hash);
+      Opal.hash_clone(self, hash);
 
-        value = map2[khash];
-
-        keys.push(key);
-        map[khash] = value;
-      }
-
-      var clone = new self.$$class.$$alloc();
-
-      clone.map  = _map;
-      clone.smap = smap;
-      clone.keys = keys;
-      clone.none = self.none;
-      clone.proc = self.proc;
-
-      return clone;
+      return hash;
     }
   end
 
-  def default(val = undefined)
+  def default(key = undefined)
     %x{
-      if (val !== undefined && self.proc !== nil) {
-        return #{@proc.call(self, val)};
+      if (key !== undefined && #@proc !== nil) {
+        return #@proc.$call(self, key);
       }
-      return self.none;
+      return #@none;
     }
   end
 
   def default=(object)
     %x{
       self.proc = nil;
-      return (self.none = object);
+      self.none = object;
+
+      return object;
     }
   end
 
@@ -273,75 +201,59 @@ class Hash
       if (proc !== nil) {
         proc = #{Opal.coerce_to!(proc, Proc, :to_proc)};
 
-        if (#{proc.lambda?} && #{proc.arity.abs} != 2) {
-          #{raise TypeError, "default_proc takes two arguments"};
+        if (#{proc.lambda?} && #{proc.arity.abs} !== 2) {
+          #{raise TypeError, 'default_proc takes two arguments'};
         }
       }
+
       self.none = nil;
-      return (self.proc = proc);
+      self.proc = proc;
+
+      return proc;
     }
   end
 
   def delete(key, &block)
     %x{
-      var result, map, khash;
-
-      if (key.$$is_string) {
-        map = self.smap;
-        khash = key;
-      } else {
-        map = self.map;
-        khash = key.$hash();
-      }
-
-      result = map[khash];
+      var value = Opal.hash_delete(self, key);
 
-      if (result != null) {
-        delete map[khash];
-        self.keys.$delete(key);
-
-        return result;
+      if (value !== undefined) {
+        return value;
       }
 
       if (block !== nil) {
         return #{block.call(key)};
       }
+
       return nil;
     }
   end
 
   def delete_if(&block)
-    return enum_for :delete_if unless block
+    return enum_for(:delete_if){self.size} unless block
 
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          map, key, value, obj, khash;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          map = smap;
-          khash = key;
+          value = self.smap[key];
         } else {
-          map = _map;
-          khash = key.$hash();
+          value = key.value;
+          key = key.key;
         }
-        obj = map[khash];
-        value = block(key, obj);
 
-        if (value === $breaker) {
+        obj = block(key, value);
+
+        if (obj === $breaker) {
           return $breaker.$v;
         }
 
-        if (value !== false && value !== nil) {
-          keys.splice(i, 1);
-          delete map[khash];
-
-          length--;
-          i--;
+        if (obj !== false && obj !== nil) {
+          if (Opal.hash_delete(self, key) !== undefined) {
+            length--;
+            i--;
+          }
         }
       }
 
@@ -352,28 +264,22 @@ class Hash
   alias dup clone
 
   def each(&block)
-    return enum_for :each unless block
+    return enum_for(:each){self.size} unless block
 
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          map, key, khash, value;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          map = smap;
-          khash = key;
+          value = self.smap[key];
         } else {
-          map = _map;
-          khash = key.$hash();
+          value = key.value;
+          key = key.key;
         }
 
-        value = Opal.yield1(block, [key, map[khash]]);
+        obj = Opal.yield1(block, [key, value]);
 
-        if (value === $breaker) {
+        if (obj === $breaker) {
           return $breaker.$v;
         }
       }
@@ -383,15 +289,13 @@ class Hash
   end
 
   def each_key(&block)
-    return enum_for :each_key unless block
-    # @keys.each(&block)
-    %x{
-      var keys = self.keys, key;
+    return enum_for(:each_key){self.size} unless block
 
-      for (var i = 0, length = keys.length; i < length; i++) {
+    %x{
+      for (var i = 0, keys = self.keys, length = keys.length, key; i < length; i++) {
         key = keys[i];
 
-        if (block(key) === $breaker) {
+        if (block(key.$$is_string ? key : key.key) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -403,25 +307,13 @@ class Hash
   alias each_pair each
 
   def each_value(&block)
-    return enum_for :each_value unless block
+    return enum_for(:each_value){self.size} unless block
 
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys, key, map, khash;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key; i < length; i++) {
         key = keys[i];
 
-        if (key.$$is_string) {
-          map = smap;
-          khash = key;
-        } else {
-          map = _map;
-          khash = key.$hash();
-        }
-
-        if (block(map[khash]) === $breaker) {
+        if (block(key.$$is_string ? self.smap[key] : key.value) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -438,74 +330,59 @@ class Hash
 
   def fetch(key, defaults = undefined, &block)
     %x{
-      var map, khash, value;
-
-      if (key.$$is_string) {
-        khash = key;
-        map = self.smap;
-      } else {
-        khash = key.$hash();
-        map = self.map;
-      }
-
-      value = map[khash];
+      var value = Opal.hash_get(self, key);
 
-      if (value != null) {
+      if (value !== undefined) {
         return value;
       }
 
       if (block !== nil) {
-        var value;
+        value = block(key);
 
-        if ((value = block(key)) === $breaker) {
+        if (value === $breaker) {
           return $breaker.$v;
         }
 
         return value;
       }
 
-      if (defaults != null) {
+      if (defaults !== undefined) {
         return defaults;
       }
-
-      #{ raise KeyError, "key not found: #{key.inspect}" };
     }
+
+    raise KeyError, "key not found: #{key.inspect}"
   end
 
-  def flatten(level=undefined)
+  def flatten(level = 1)
+    level = Opal.coerce_to!(level, Integer, :to_int)
+
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          result = [],
-          map, key, khash, value;
+      var result = [];
 
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
+          value = key.value;
+          key = key.key;
         }
 
-        value = map[khash];
-
         result.push(key);
 
         if (value.$$is_array) {
-          if (level == null || level === 1) {
+          if (level === 1) {
             result.push(value);
+            continue;
           }
-          else {
-            result = result.concat(#{`value`.flatten(`level - 1`)});
-          }
-        }
-        else {
-          result.push(value);
+
+          result = result.concat(#{`value`.flatten(`level - 2`)});
+          continue;
         }
+
+        result.push(value);
       }
 
       return result;
@@ -513,48 +390,15 @@ class Hash
   end
 
   def has_key?(key)
-    %x{
-      var keys = self.keys,
-          map, khash;
-
-      if (key.$$is_string) {
-        khash = key;
-        map = self.smap;
-      } else {
-        khash = key.$hash();
-        map = self.map;
-      }
-
-      if (Opal.hasOwnProperty.call(map, khash)) {
-        for (var i = 0, length = keys.length; i < length; i++) {
-          if (!#{not(key.eql?(`keys[i]`))}) {
-            return true;
-          }
-        }
-      }
-
-      return false;
-    }
+    `Opal.hash_get(self, key) !== undefined`
   end
 
   def has_value?(value)
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys, key, map, khash;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key; i < length; i++) {
         key = keys[i];
 
-        if (key.$$is_string) {
-          map = smap;
-          khash = key;
-        } else {
-          map = _map;
-          khash = key.$hash();
-        }
-
-        if (#{`map[khash]` == value}) {
+        if (#{`(key.$$is_string ? self.smap[key] : key.value)` == value}) {
           return true;
         }
       }
@@ -563,39 +407,48 @@ class Hash
     }
   end
 
-  `var hash_ids = null;`
   def hash
     %x{
-      var top = (hash_ids === null);
-      try {
-        var key, value,
-            hash = ['Hash'],
-            keys = self.keys,
-            id = self.$object_id(),
-            counter = 0;
+      var top = (Opal.hash_ids === undefined),
+          hash_id = self.$object_id(),
+          result = ['Hash'],
+          key, item;
 
+      try {
         if (top) {
-          hash_ids = {}
+          Opal.hash_ids = {};
         }
 
-        if (hash_ids.hasOwnProperty(id)) {
+        if (Opal.hash_ids.hasOwnProperty(hash_id)) {
           return 'self';
         }
 
-        hash_ids[id] = true;
+        for (key in Opal.hash_ids) {
+          if (Opal.hash_ids.hasOwnProperty(key)) {
+            item = Opal.hash_ids[key];
+            if (#{eql?(`item`)}) {
+              return 'self';
+            }
+          }
+        }
+
+        Opal.hash_ids[hash_id] = self;
 
-        for (var i = 0, length = keys.length; i < length; i++) {
-          key   = keys[i];
-          value = key.$$is_string ? self.smap[key] : self.map[key.$hash()];
-          key   = key.$hash();
-          value = (typeof(value) === 'undefined') ? '' : value.$hash();
-          hash.push([key,value]);
+        for (var i = 0, keys = self.keys, length = keys.length; i < length; i++) {
+          key = keys[i];
+
+          if (key.$$is_string) {
+            result.push([key, self.smap[key].$hash()]);
+          } else {
+            result.push([key.key_hash, key.value.$hash()]);
+          }
         }
 
-        return hash.sort().join();
+        return result.sort().join();
+
       } finally {
         if (top) {
-          hash_ids = null;
+          delete Opal.hash_ids;
         }
       }
     }
@@ -605,23 +458,17 @@ class Hash
 
   def index(object)
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          map, khash, key;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          map = smap;
-          khash = key;
+          value = self.smap[key];
         } else {
-          map = _map;
-          khash = key.$hash();
+          value = key.value;
+          key = key.key;
         }
 
-        if (#{`map[khash]` == object}) {
+        if (#{`value` == object}) {
           return key;
         }
       }
@@ -630,32 +477,20 @@ class Hash
     }
   end
 
-  def indexes(*keys)
+  def indexes(*args)
     %x{
-      var result = [],
-          _map = self.map,
-          smap = self.smap,
-          map, key, khash, value;
+      var result = [];
 
-      for (var i = 0, length = keys.length; i < length; i++) {
-        key = keys[i];
+      for (var i = 0, length = args.length, key, value; i < length; i++) {
+        key = args[i];
+        value = Opal.hash_get(self, key);
 
-        if (key.$$is_string) {
-          khash = key;
-          map = smap;
-        } else {
-          khash = key.$hash();
-          map = _map;
+        if (value === undefined) {
+          result.push(#{default});
+          continue;
         }
 
-        value = map[khash];
-
-        if (value != null) {
-          result.push(value);
-        }
-        else {
-          result.push(self.none);
-        }
+        result.push(value);
       }
 
       return result;
@@ -664,41 +499,43 @@ class Hash
 
   alias indices indexes
 
-  `var inspect_ids = null;`
+  `var inspect_ids;`
+
   def inspect
     %x{
-      var top = (inspect_ids === null);
-      try {
-
-        var key, value,
-            inspect = [],
-            keys = self.keys,
-            id = self.$object_id(),
-            counter = 0;
+      var top = (inspect_ids === undefined),
+          hash_id = self.$object_id(),
+          result = [];
 
+      try {
         if (top) {
-          inspect_ids = {}
+          inspect_ids = {};
         }
 
-        if (inspect_ids.hasOwnProperty(id)) {
+        if (inspect_ids.hasOwnProperty(hash_id)) {
           return '{...}';
         }
 
-        inspect_ids[id] = true;
+        inspect_ids[hash_id] = true;
+
+        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;
+          }
 
-        for (var i = 0, length = keys.length; i < length; i++) {
-          key   = keys[i];
-          value = key.$$is_string ? self.smap[key] : self.map[key.$hash()];
-          key   = key.$inspect();
-          value = value.$inspect();
-          inspect.push(key + '=>' + value);
+          result.push(key.$inspect() + '=>' + value.$inspect());
         }
 
-        return '{' + inspect.join(', ') + '}';
-      } finally {
+        return '{' + result.join(', ') + '}';
 
+      } finally {
         if (top) {
-          inspect_ids = null;
+          inspect_ids = undefined;
         }
       }
     }
@@ -706,77 +543,50 @@ class Hash
 
   def invert
     %x{
-      var result = Opal.hash(),
-          keys = self.keys,
-          _map = self.map,
-          smap = self.smap,
-          keys2 = result.keys,
-          _map2 = result.map,
-          smap2 = result.smap,
-          map, map2, key, khash, value;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      var hash = Opal.hash();
+
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          map = smap;
-          khash = key;
-        } else {
-          map = _map;
-          khash = key.$hash();
-        }
-
-        value = map[khash];
-        keys2.push(value);
-
-        if (value.$$is_string) {
-          map2 = smap2;
-          khash = value;
+          value = self.smap[key];
         } else {
-          map2 = _map2;
-          khash = value.$hash();
+          value = key.value;
+          key = key.key;
         }
 
-        map2[khash] = key;
+        Opal.hash_put(hash, value, key);
       }
 
-      return result;
+      return hash;
     }
   end
 
   def keep_if(&block)
-    return enum_for :keep_if unless block
+    return enum_for(:keep_if){self.size} unless block
 
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          map, key, khash, value, keep;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
+          value = key.value;
+          key = key.key;
         }
 
-        value = map[khash];
-        keep  = block(key, value);
+        obj = block(key, value);
 
-        if (keep === $breaker) {
+        if (obj === $breaker) {
           return $breaker.$v;
         }
 
-        if (keep === false || keep === nil) {
-          keys.splice(i, 1);
-          delete map[khash];
-
-          length--;
-          i--;
+        if (obj === false || obj === nil) {
+          if (Opal.hash_delete(self, key) !== undefined) {
+            length--;
+            i--;
+          }
         }
       }
 
@@ -789,7 +599,21 @@ class Hash
   alias key? has_key?
 
   def keys
-    `self.keys.slice(0)`
+    %x{
+      var result = [];
+
+      for (var i = 0, keys = self.keys, length = keys.length, key; i < length; i++) {
+        key = keys[i];
+
+        if (key.$$is_string) {
+          result.push(key);
+        } else {
+          result.push(key.key);
+        }
+      }
+
+      return result;
+    }
   end
 
   def length
@@ -799,75 +623,52 @@ class Hash
   alias member? has_key?
 
   def merge(other, &block)
-    unless Hash === other
-      other = Opal.coerce_to!(other, Hash, :to_hash)
-    end
-
-    cloned = clone
-    cloned.merge!(other, &block)
-    cloned
+    dup.merge!(other, &block)
   end
 
   def merge!(other, &block)
     %x{
-      if (! #{Hash === other}) {
+      if (!#{Hash === other}) {
         other = #{Opal.coerce_to!(other, Hash, :to_hash)};
       }
 
-      var keys  = self.keys,
-          _map  = self.map,
-          smap  = self.smap,
-          keys2 = other.keys,
-          _map2 = other.map,
-          smap2 = other.smap,
-          map, map2, key, khash, value, value2;
+      var i, other_keys = other.keys, length = other_keys.length, key, value, other_value;
 
       if (block === nil) {
-        for (var i = 0, length = keys2.length; i < length; i++) {
-          key = keys2[i];
+        for (i = 0; i < length; i++) {
+          key = other_keys[i];
 
           if (key.$$is_string) {
-            khash = key;
-            map = smap;
-            map2 = smap2;
+            other_value = other.smap[key];
           } else {
-            khash = key.$hash();
-            map = _map;
-            map2 = _map2;
+            other_value = key.value;
+            key = key.key;
           }
 
-          if (map[khash] == null) {
-            keys.push(key);
-          }
-
-          map[khash] = map2[khash];
+          Opal.hash_put(self, key, other_value);
         }
+
+        return self;
       }
-      else {
-        for (var i = 0, length = keys2.length; i < length; i++) {
-          key    = keys2[i];
 
-          if (key.$$is_string) {
-            khash = key;
-            map = smap;
-            map2 = smap2;
-          } else {
-            khash = key.$hash();
-            map = _map;
-            map2 = _map2;
-          }
+      for (i = 0; i < length; i++) {
+        key = other_keys[i];
+
+        if (key.$$is_string) {
+          other_value = other.smap[key];
+        } else {
+          other_value = key.value;
+          key = key.key;
+        }
 
-          value  = map[khash];
-          value2 = map2[khash];
+        value = Opal.hash_get(self, key);
 
-          if (value == null) {
-            keys.push(key);
-            map[khash] = value2;
-          }
-          else {
-            map[khash] = block(key, value, value2);
-          }
+        if (value === undefined) {
+          Opal.hash_put(self, key, other_value);
+          continue;
         }
+
+        Opal.hash_put(self, key, block(key, value, other_value));
       }
 
       return self;
@@ -876,24 +677,16 @@ class Hash
 
   def rassoc(object)
     %x{
-      var keys = self.keys,
-          _map = self.map,
-          smap = self.smap,
-          key, khash, value, map;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
-        key = keys[i]
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
+        key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
+          value = key.value;
+          key = key.key;
         }
 
-        value = map[khash];
-
         if (#{`value` == object}) {
           return [key, value];
         }
@@ -903,156 +696,167 @@ class Hash
     }
   end
 
+  def rehash
+    %x{
+      Opal.hash_rehash(self);
+      return self;
+    }
+  end
+
   def reject(&block)
-    return enum_for :reject unless block
+    return enum_for(:reject){self.size} unless block
 
     %x{
-      var keys   = self.keys,
-          _map    = self.map,
-          smap    = self.smap,
-          result = Opal.hash(),
-          _map2   = result.map,
-          smap2   = result.smap,
-          keys2  = result.keys,
-          map, map2, key, khash, object, value;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      var hash = Opal.hash();
+
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
-          map2 = smap2;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
-          map2 = _map2;
+          value = key.value;
+          key = key.key;
         }
 
-        object = map[khash];
+        obj = block(key, value);
 
-        if ((value = block(key, object)) === $breaker) {
+        if (obj === $breaker) {
           return $breaker.$v;
         }
 
-        if (value === false || value === nil) {
-          keys2.push(key);
-          map2[khash] = object;
+        if (obj === false || obj === nil) {
+          Opal.hash_put(hash, key, value);
         }
       }
 
-      return result;
+      return hash;
     }
   end
 
-  def replace(other)
+  def reject!(&block)
+    return enum_for(:reject!){self.size} unless block
+
     %x{
-      var keys  = self.keys = [],
-          _map  = self.map  = {},
-          smap  = self.smap = {},
-          _map2 = other.map,
-          smap2 = other.smap,
-          key, khash, map, map2;
+      var changes_were_made = false;
 
-      for (var i = 0, length = other.keys.length; i < length; i++) {
-        key = other.keys[i];
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
+        key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
-          map2 = smap2;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
-          map2 = _map2;
+          value = key.value;
+          key = key.key;
+        }
+
+        obj = block(key, value);
+
+        if (obj === $breaker) {
+          return $breaker.$v;
         }
 
-        keys.push(key);
-        map[khash] = map2[khash];
+        if (obj !== false && obj !== nil) {
+          if (Opal.hash_delete(self, key) !== undefined) {
+            changes_were_made = true;
+            length--;
+            i--;
+          }
+        }
       }
 
-      return self;
+      return changes_were_made ? self : nil;
+    }
+  end
+
+  def replace(other)
+    other = Opal.coerce_to!(other, Hash, :to_hash)
+
+    %x{
+      Opal.hash_init(self);
+
+      for (var i = 0, other_keys = other.keys, length = other_keys.length, key, value, other_value; i < length; i++) {
+        key = other_keys[i];
+
+        if (key.$$is_string) {
+          other_value = other.smap[key];
+        } else {
+          other_value = key.value;
+          key = key.key;
+        }
+
+        Opal.hash_put(self, key, other_value);
+      }
     }
+
+    if other.default_proc
+      self.default_proc = other.default_proc
+    else
+      self.default = other.default
+    end
+
+    self
   end
 
   def select(&block)
-    return enum_for :select unless block
+    return enum_for(:select){self.size} unless block
 
     %x{
-      var keys   = self.keys,
-          _map   = self.map,
-          smap   = self.smap,
-          result = Opal.hash(),
-          _map2  = result.map,
-          smap2  = result.smap,
-          keys2  = result.keys,
-          map, map2, key, khash, value, object;
-
-      for (var i = 0, length = keys.length; i < length; i++) {
+      var hash = Opal.hash();
+
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
-          map2 = smap2;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
-          map2 = _map2;
+          value = key.value;
+          key = key.key;
         }
 
-        value = map[khash];
-        object = block(key, value);
+        obj = block(key, value);
 
-        if (object === $breaker) {
+        if (obj === $breaker) {
           return $breaker.$v;
         }
 
-        if (object !== false && object !== nil) {
-          keys2.push(key);
-          map2[khash] = value;
+        if (obj !== false && obj !== nil) {
+          Opal.hash_put(hash, key, value);
         }
       }
 
-      return result;
+      return hash;
     }
   end
 
   def select!(&block)
-    return enum_for :select! unless block
+    return enum_for(:select!){self.size} unless block
 
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          result = nil,
-          key, khash, value, object, map;
+      var result = nil;
 
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
+          value = key.value;
+          key = key.key;
         }
 
-        value = map[khash];
-        object = block(key, value);
+        obj = block(key, value);
 
-        if (object === $breaker) {
+        if (obj === $breaker) {
           return $breaker.$v;
         }
 
-        if (object === false || object === nil) {
-          keys.splice(i, 1);
-          delete map[khash];
-
-          length--;
-          i--;
-          result = self
+        if (obj === false || obj === nil) {
+          if (Opal.hash_delete(self, key) !== undefined) {
+            length--;
+            i--;
+          }
+          result = self;
         }
       }
 
@@ -1063,28 +867,17 @@ class Hash
   def shift
     %x{
       var keys = self.keys,
-          _map = self.map,
-          smap = self.smap,
-          map, key, khash, value;
+          key;
 
-      if (keys.length) {
+      if (keys.length > 0) {
         key = keys[0];
-        if (key.$$is_string) {
-          khash = key;
-          map = smap;
-        } else {
-          khash = key.$hash();
-          map = _map;
-        }
-        value = map[khash];
 
-        delete map[khash];
-        keys.splice(0, 1);
+        key = key.$$is_string ? key : key.key;
 
-        return [key, value];
+        return [key, Opal.hash_delete(self, key)];
       }
 
-      return nil;
+      return self.$default(nil);
     }
   end
 
@@ -1094,24 +887,19 @@ class Hash
 
   def to_a
     %x{
-      var keys = self.keys,
-          _map = self.map,
-          smap = self.smap,
-          result = [],
-          map, key, khash;
+      var result = [];
 
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key, value; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
+          value = self.smap[key];
         } else {
-          khash = key.$hash();
-          map = _map;
+          value = key.value;
+          key = key.key;
         }
 
-        result.push([key, map[khash]]);
+        result.push([key, value]);
       }
 
       return result;
@@ -1121,17 +909,13 @@ class Hash
   def to_h
     %x{
       if (self.$$class === Opal.Hash) {
-        return self
+        return self;
       }
 
-      var hash   = new Opal.Hash.$$alloc,
-          cloned = #{clone};
+      var hash = new Opal.Hash.$$alloc();
 
-      hash.map  = cloned.map;
-      hash.smap = cloned.smap;
-      hash.keys = cloned.keys;
-      hash.none = cloned.none;
-      hash.proc = cloned.proc;
+      Opal.hash_init(hash);
+      Opal.hash_clone(self, hash);
 
       return hash;
     }
@@ -1151,24 +935,16 @@ class Hash
 
   def values
     %x{
-      var _map = self.map,
-          smap = self.smap,
-          keys = self.keys,
-          result = [],
-          map, khash, key;
+      var result = [];
 
-      for (var i = 0, length = keys.length; i < length; i++) {
+      for (var i = 0, keys = self.keys, length = keys.length, key; i < length; i++) {
         key = keys[i];
 
         if (key.$$is_string) {
-          khash = key;
-          map = smap;
+          result.push(self.smap[key]);
         } else {
-          khash = key.$hash();
-          map = _map;
+          result.push(key.value);
         }
-
-        result.push(map[khash]);
       }
 
       return result;