corelib/hash.rb in opal-0.4.4 vs corelib/hash.rb in opal-0.5.0

@@ -6,25 +6,39 @@
       if (arguments.length == 1 && arguments[0]._klass == Hash) {
         return arguments[0];
       }
 
       var hash   = new Hash._alloc,
-          args   = $slice.call(arguments),
           keys   = [],
           assocs = {};
 
       hash.map   = assocs;
       hash.keys  = keys;
 
-      for (var i = 0, length = args.length, key; i < length; i++) {
-        var key = args[i], obj = args[++i];
+      if (arguments.length == 1 && arguments[0]._isArray) {
+        var args = arguments[0];
 
-        if (assocs[key] == null) {
-          keys.push(key);
+        for (var i = 0, length = args.length; i < length; i++) {
+          var key = args[i][0], obj = args[i][1];
+
+          if (assocs[key] == null) {
+            keys.push(key);
+          }
+
+          assocs[key] = obj;
         }
+      }
+      else {
+        for (var i = 0, length = arguments.length, key; i < length; i++) {
+          var key = arguments[i], obj = arguments[++i];
 
-        assocs[key] = obj;
+          if (assocs[key] == null) {
+            keys.push(key);
+          }
+
+          assocs[key] = obj;
+        }
       }
 
       return hash;
     };
   }
@@ -48,59 +62,59 @@
     `$hash.apply(null, objs)`
   end
 
   def self.allocate
     %x{
-      var hash = new #{self}._alloc;
+      var hash = new self._alloc;
       hash.map = {};
       hash.keys = [];
       return hash;
     }
   end
 
   def initialize(defaults = undefined, &block)
     %x{
       if (defaults != null) {
         if (defaults.constructor == Object) {
-          var map = #{self}.map, keys = #{self}.keys;
+          var map = self.map, keys = self.keys;
 
           for (var key in defaults) {
             keys.push(key);
             map[key] = defaults[key];
           }
         }
         else {
-          #{self}.none = defaults;
+          self.none = defaults;
         }
       }
       else if (block !== nil) {
-          #{self}.proc = block;
+          self.proc = block;
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def ==(other)
     %x{
-      if (#{self} === other) {
+      if (self === other) {
         return true;
       }
 
       if (!other.map || !other.keys) {
         return false;
       }
 
-      if (#{self}.keys.length !== other.keys.length) {
+      if (self.keys.length !== other.keys.length) {
         return false;
       }
 
-      var map  = #{self}.map,
+      var map  = self.map,
           map2 = other.map;
 
-      for (var i = 0, length = #{self}.keys.length; i < length; i++) {
-        var key = #{self}.keys[i], obj = map[key], obj2 = map2[key];
+      for (var i = 0, length = self.keys.length; i < length; i++) {
+        var key = self.keys[i], obj = map[key], obj2 = map2[key];
 
         if (#{`obj` != `obj2`}) {
           return false;
         }
       }
@@ -109,74 +123,77 @@
     }
   end
 
   def [](key)
     %x{
-      var bucket = #{self}.map[key];
+      var map = self.map;
 
-      if (bucket != null) {
-        return bucket;
+      if ($hasOwn.call(map, key)) {
+        return map[key];
       }
 
-      var proc = #{@proc};
+      var proc = #@proc;
 
       if (proc !== nil) {
         return #{ `proc`.call self, key };
       }
 
-      return #{@none};
+      return #@none;
     }
   end
 
   def []=(key, value)
     %x{
-      var map = #{self}.map;
+      var map = self.map;
 
       if (!$hasOwn.call(map, key)) {
-        #{self}.keys.push(key);
+        self.keys.push(key);
       }
 
       map[key] = value;
 
       return value;
     }
   end
 
   def assoc(object)
     %x{
-      var keys = #{self}.keys, key;
+      var keys = self.keys, key;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         key = keys[i];
 
         if (#{`key` == object}) {
-          return [key, #{self}.map[key]];
+          return [key, self.map[key]];
         }
       }
 
       return nil;
     }
   end
 
   def clear
     %x{
-      #{self}.map = {};
-      #{self}.keys = [];
-      return #{self};
+      self.map = {};
+      self.keys = [];
+      return self;
     }
   end
 
   def clone
     %x{
-      var result = $hash(),
-          map    = #{self}.map,
+      var result = new self._klass._alloc();
+
+      result.map = {}; result.keys = [];
+
+      var map    = self.map,
           map2   = result.map,
           keys2  = result.keys;
 
-      for (var i = 0, length = #{self}.keys.length; i < length; i++) {
-        keys2.push(#{self}.keys[i]);
-        map2[#{self}.keys[i]] = map[#{self}.keys[i]];
+      for (var i = 0, length = self.keys.length; i < length; i++) {
+        keys2.push(self.keys[i]);
+        map2[self.keys[i]] = map[self.keys[i]];
       }
 
       return result;
     }
   end
@@ -197,15 +214,15 @@
     @proc = proc
   end
 
   def delete(key)
     %x{
-      var map  = #{self}.map, result = map[key];
+      var map  = self.map, result = map[key];
 
       if (result != null) {
         delete map[key];
-        #{self}.keys.$delete(key);
+        self.keys.$delete(key);
 
         return result;
       }
 
       return nil;
@@ -214,11 +231,11 @@
 
   def delete_if(&block)
     return enum_for :delete_if unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys, value;
+      var map = self.map, keys = self.keys, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
 
         if ((value = block(key, obj)) === $breaker) {
@@ -232,77 +249,81 @@
           length--;
           i--;
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   alias dup clone
 
   def each(&block)
     return enum_for :each unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys;
+      var map  = self.map,
+          keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i];
+        var key   = keys[i],
+            value = $opal.$yield1(block, [key, map[key]]);
 
-        #{yield [`key`, `map[key]`]};
+        if (value === $breaker) {
+          return $breaker.$v;
+        }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def each_key(&block)
     return enum_for :each_key unless block
 
     %x{
-      var keys = #{self}.keys;
+      var keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
 
         if (block(key) === $breaker) {
           return $breaker.$v;
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   alias each_pair each
 
   def each_value(&block)
     return enum_for :each_value unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys;
+      var map = self.map, keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         if (block(map[keys[i]]) === $breaker) {
           return $breaker.$v;
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def empty?
-    `#{self}.keys.length === 0`
+    `self.keys.length === 0`
   end
 
   alias eql? ==
 
   def fetch(key, defaults = undefined, &block)
     %x{
-      var value = #{self}.map[key];
+      var value = self.map[key];
 
       if (value != null) {
         return value;
       }
 
@@ -324,11 +345,11 @@
     }
   end
 
   def flatten(level=undefined)
     %x{
-      var map = #{self}.map, keys = #{self}.keys, result = [];
+      var map = self.map, keys = self.keys, result = [];
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], value = map[key];
 
         result.push(key);
@@ -349,59 +370,59 @@
       return result;
     }
   end
 
   def has_key?(key)
-    `#{self}.map[key] != null`
+    `$hasOwn.call(self.map, key)`
   end
 
   def has_value?(value)
     %x{
-      for (var assoc in #{self}.map) {
-        if (#{`#{self}.map[assoc]` == value}) {
+      for (var assoc in self.map) {
+        if (#{`self.map[assoc]` == value}) {
           return true;
         }
       }
 
       return false;
     }
   end
 
   def hash
-    `#{self}._id`
+    `self._id`
   end
 
   alias include? has_key?
 
   def index(object)
     %x{
-      var map = #{self}.map, keys = #{self}.keys;
+      var map = self.map, keys = self.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
 
-        if (#{object == `map[key]`}) {
+        if (#{`map[key]` == object}) {
           return key;
         }
       }
 
       return nil;
     }
   end
 
   def indexes(*keys)
     %x{
-      var result = [], map = #{self}.map, val;
+      var result = [], map = self.map, val;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], val = map[key];
 
         if (val != null) {
           result.push(val);
         }
         else {
-          result.push(#{self}.none);
+          result.push(self.none);
         }
       }
 
       return result;
     }
@@ -409,16 +430,16 @@
 
   alias indices indexes
 
   def inspect
     %x{
-      var inspect = [], keys = #{self}.keys, map = #{self}.map;
+      var inspect = [], keys = self.keys, map = self.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], val = map[key];
 
-        if (val === #{self}) {
+        if (val === self) {
           inspect.push(#{`key`.inspect} + '=>' + '{...}');
         } else {
           inspect.push(#{`key`.inspect} + '=>' + #{`map[key]`.inspect});
         }
       }
@@ -427,11 +448,11 @@
     }
   end
 
   def invert
     %x{
-      var result = $hash(), keys = #{self}.keys, map = #{self}.map,
+      var result = $hash(), keys = self.keys, map = self.map,
           keys2 = result.keys, map2 = result.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
 
@@ -445,11 +466,11 @@
 
   def keep_if(&block)
     return enum_for :keep_if unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys, value;
+      var map = self.map, keys = self.keys, value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
 
         if ((value = block(key, obj)) === $breaker) {
@@ -463,35 +484,31 @@
           length--;
           i--;
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   alias key index
 
   alias key? has_key?
 
   def keys
-    %x{
-      return #{self}.keys.slice(0);
-    }
+    `self.keys.slice(0)`
   end
 
   def length
-    %x{
-      return #{self}.keys.length;
-    }
+    `self.keys.length`
   end
 
   alias member? has_key?
 
   def merge(other, &block)
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           result = $hash(), keys2 = result.keys, map2 = result.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
 
@@ -530,11 +547,11 @@
     }
   end
 
   def merge!(other, &block)
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           keys2 = other.keys, map2 = other.map;
 
       if (block === nil) {
         for (var i = 0, length = keys2.length; i < length; i++) {
           var key = keys2[i];
@@ -558,17 +575,17 @@
             map[key] = block(key, map[key], map2[key]);
           }
         }
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def rassoc(object)
     %x{
-      var keys = #{self}.keys, map = #{self}.map;
+      var keys = self.keys, map = self.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
 
         if (#{`obj` == object}) {
@@ -582,11 +599,11 @@
 
   def reject(&block)
     return enum_for :reject unless block
 
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           result = $hash(), map2 = result.map, keys2 = result.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key], value;
 
@@ -604,27 +621,27 @@
     }
   end
 
   def replace(other)
     %x{
-      var map = #{self}.map = {}, keys = #{self}.keys = [];
+      var map = self.map = {}, keys = self.keys = [];
 
       for (var i = 0, length = other.keys.length; i < length; i++) {
         var key = other.keys[i];
         keys.push(key);
         map[key] = other.map[key];
       }
 
-      return #{self};
+      return self;
     }
   end
 
   def select(&block)
     return enum_for :select unless block
 
     %x{
-      var keys = #{self}.keys, map = #{self}.map,
+      var keys = self.keys, map = self.map,
           result = $hash(), map2 = result.map, keys2 = result.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key], value;
 
@@ -644,11 +661,11 @@
 
   def select!(&block)
     return enum_for :select! unless block
 
     %x{
-      var map = #{self}.map, keys = #{self}.keys, value, result = nil;
+      var map = self.map, keys = self.keys, value, result = nil;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key];
 
         if ((value = block(key, obj)) === $breaker) {
@@ -659,21 +676,21 @@
           keys.splice(i, 1);
           delete map[key];
 
           length--;
           i--;
-          result = #{self}
+          result = self
         }
       }
 
       return result;
     }
   end
 
   def shift
     %x{
-      var keys = #{self}.keys, map = #{self}.map;
+      var keys = self.keys, map = self.map;
 
       if (keys.length) {
         var key = keys[0], obj = map[key];
 
         delete map[key];
@@ -686,13 +703,15 @@
     }
   end
 
   alias size length
 
+  alias_method :store, :[]=
+
   def to_a
     %x{
-      var keys = #{self}.keys, map = #{self}.map, result = [];
+      var keys = self.keys, map = self.map, result = [];
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
         result.push([key, map[key]]);
       }
@@ -705,16 +724,21 @@
     self
   end
 
   def to_n
     %x{
-      var result = {}, keys = #{self}.keys, map = #{self}.map, bucket, value;
+      var result = {},
+          keys   = self.keys,
+          map    = self.map,
+          bucket,
+          value;
 
       for (var i = 0, length = keys.length; i < length; i++) {
-        var key = keys[i], obj = map[key];
+        var key = keys[i],
+            obj = map[key];
 
-        if (obj.$to_n) {
+        if (#{`obj`.respond_to? :to_n}) {
           result[key] = #{`obj`.to_n};
         }
         else {
           result[key] = obj;
         }
@@ -726,29 +750,16 @@
 
   alias to_s inspect
 
   alias update merge!
 
-  def value?(value)
-    %x{
-      var map = #{self}.map;
+  alias value? has_value?
 
-      for (var assoc in map) {
-        var v = map[assoc];
-        if (#{`v` == value}) {
-          return true;
-        }
-      }
-
-      return false;
-    }
-  end
-
   alias values_at indexes
 
   def values
     %x{
-      var map    = #{self}.map,
+      var map    = self.map,
           result = [];
 
       for (var key in map) {
         result.push(map[key]);
       }