opal · Oct 23, 2014 · Oct 23, 2014 · Oct 23, 2014
Showing with 33 additions and 21 deletions.

+32 −4 opal/corelib/hash.rb

+1 −1 spec/corelib

+0 −16 spec/filters/bugs/hash.rb
diff --git a/opal/corelib/hash.rb b/opal/corelib/hash.rb
@@ -346,7 +346,20 @@ def flatten(level=undefined)
   end
 
   def has_key?(key)
-    `$opal.hasOwnProperty.call(self.map, key.$hash())`
+    %x{
+      var map = self.map,
+          keys = self.keys,
+          khash = key.$hash();
+
+      if ($opal.hasOwnProperty.call(self.map, khash)) {
+        for (var i = 0, length = keys.length; i < length; i++) {
+          if (!#{not(key.eql?(`keys[i]`))}) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
   end
 
   def has_value?(value)
@@ -411,19 +424,34 @@ def indexes(*keys)
 
   alias indices indexes
 
+  `var inspect_ids = {}`
   def inspect
     %x{
-      var inspect = [], keys = self.keys, map = self.map;
+      var inspect = [],
+          keys = self.keys,
+          map = self.map,
+          top = !!inspect_ids,
+          id = #{object_id},
+          seen_string = '{...}';
+
+      if (inspect_ids.hasOwnProperty(id)) {
+        return seen_string;
+      }
+      inspect_ids[id] = true;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], val = map[key.$hash()];
-        val = (val === self) ? '{...}' : val.$inspect()
-        key = (key === self) ? '{...}' : key.$inspect()
+        val = val.$inspect();
+        key = key.$inspect();
         inspect.push(key + '=>' + val);
       }
 
       return '{' + inspect.join(', ') + '}';
     }
+  ensure
+    `if (top) {
+      inspect_ids = {}
+    }`
   end
 
   def invert

diff --git a/spec/corelib b/spec/corelib
diff --git a/spec/filters/bugs/hash.rb b/spec/filters/bugs/hash.rb
@@ -55,32 +55,18 @@
   fails "Hash#flatten recursively flattens Array values to the given depth"
   fails "Hash#flatten raises a TypeError if given a non-Integer argument"
 
-  fails "Hash#has_key? compares keys with the same #hash value via #eql?"
-  fails "Hash#has_key? returns true if argument is a key"
-
   fails "Hash#hash returns the same hash for recursive hashes through arrays"
   fails "Hash#hash returns the same hash for recursive hashes"
   fails "Hash#hash generates a hash for recursive hash structures"
   fails "Hash#hash returns a value which doesn't depend on the hash order"
 
-  fails "Hash#include? compares keys with the same #hash value via #eql?"
-  fails "Hash#include? returns true if argument is a key"
-
   fails "Hash#invert compares new keys with eql? semantics"
 
   fails "Hash#initialize_copy does not transfer default values"
   fails "Hash#initialize_copy calls to_hash on hash subclasses"
   fails "Hash#initialize_copy tries to convert the passed argument to a hash using #to_hash"
   fails "Hash#initialize_copy replaces the contents of self with other"
 
-  fails "Hash#inspect handles hashes with recursive values"
-
-  fails "Hash#key? compares keys with the same #hash value via #eql?"
-  fails "Hash#key? returns true if argument is a key"
-
-  fails "Hash#member? compares keys with the same #hash value via #eql?"
-  fails "Hash#member? returns true if argument is a key"
-
   fails "Hash#merge returns subclass instance for subclasses"
 
   fails "Hash.new raises an ArgumentError if more than one argument is passed"
@@ -115,8 +101,6 @@
 
   fails "Hash#to_h returns self for Hash instances"
 
-  fails "Hash#to_s handles hashes with recursive values"
-
   fails "Hash.try_convert does not rescue exceptions raised by #to_hash"
   fails "Hash.try_convert sends #to_hash to the argument and raises TypeError if it's not a kind of Hash"
   fails "Hash.try_convert sends #to_hash to the argument and returns the result if it's a kind of Hash"