opal 1.7.2 → 1.8.0.alpha1

data/opal/corelib/runtime.js

@@ -538,6 +538,13 @@
   Opal.$$$ = Opal.const_get_qualified;
   Opal.$r = Opal.const_get_relative_factory;
 
+  function descends_from_bridged_class(klass) {
+    if (klass == null) return false;
+    if (klass.$$bridge) return klass;
+    if (klass.$$super) return descends_from_bridged_class(klass.$$super);
+    return false;
+  }
+
   // Modules & Classes
   // -----------------
 
@@ -567,14 +574,13 @@
   // @return new [Class]  or existing ruby class
   //
   function $allocate_class(name, superclass, singleton) {
-    var klass;
+    var klass, bridged_descendant;
 
-    if (superclass != null && superclass.$$bridge) {
+    if (bridged_descendant = descends_from_bridged_class(superclass)) {
       // Inheritance from bridged classes requires
       // calling original JS constructors
       klass = function() {
-        var args = $slice(arguments),
-            self = new ($bind.apply(superclass.$$constructor, [null].concat(args)))();
+        var self = new ($bind.apply(bridged_descendant.$$constructor, $prepend(null, arguments)))();
 
         // and replacing a __proto__ manually
         $set_proto(self, klass.$$prototype);
@@ -824,6 +830,9 @@
   // @param object [Object] the ruby object
   // @return [Class] the singleton class for object
   Opal.get_singleton_class = function(object) {
+    if (object.$$is_number) {
+      $raise(Opal.TypeError, "can't define singleton");
+    }
     if (object.$$meta) {
       return object.$$meta;
     }
@@ -1535,7 +1544,6 @@
   // @param method_name [String] The js-name of the method to stub (e.g. "$foo")
   // @return [undefined]
   Opal.stub_for = function(method_name) {
-
     function method_missing_stub() {
       // Copy any given block onto the method_missing dispatcher
       this.$method_missing.$$p = method_missing_stub.$$p;
@@ -1544,11 +1552,8 @@
       method_missing_stub.$$p = null;
 
       // call method missing with correct args (remove '$' prefix on method name)
-      var args_ary = new Array(arguments.length);
-      for(var i = 0, l = args_ary.length; i < l; i++) { args_ary[i] = arguments[i]; }
-
-      return this.$method_missing.apply(this, [method_name.slice(1)].concat(args_ary));
-    }
+      return this.$method_missing.apply(this, $prepend(method_name.slice(1), arguments));
+    };
 
     method_missing_stub.$$stub = true;
 
@@ -1690,13 +1695,6 @@
       }
     }
 
-    if (!args.$$is_array) {
-      var args_ary = new Array(args.length);
-      for(var i = 0, l = args_ary.length; i < l; i++) { args_ary[i] = args[i]; }
-
-      return block.apply(null, args_ary);
-    }
-
     return block.apply(null, args);
   };
 
@@ -1809,11 +1807,10 @@
   };
 
   // Used for extracting keyword arguments from arguments passed to
-  // JS function. If provided +arguments+ list doesn't have a Hash
-  // as a last item, returns a blank Hash.
+  // JS function.
   //
   // @param parameters [Array]
-  // @return [Hash]
+  // @return [Hash] or undefined
   //
   Opal.extract_kwargs = function(parameters) {
     var kwargs = parameters[parameters.length - 1];
@@ -1825,7 +1822,7 @@
 
   // Used to get a list of rest keyword arguments. Method takes the given
   // keyword args, i.e. the hash literal passed to the method containing all
-  // keyword arguemnts passed to method, as well as the used args which are
+  // keyword arguments passed to method, as well as the used args which are
   // the names of required and optional arguments defined. This method then
   // just returns all key/value pairs which have not been used, in a new
   // hash literal.
@@ -1835,19 +1832,16 @@
   // @return [Hash]
   //
   Opal.kwrestargs = function(given_args, used_args) {
-    var keys      = [],
-        map       = {},
-        key           ,
-        given_map = given_args.$$smap;
+    var map = new Map();
 
-    for (key in given_map) {
+    Opal.hash_each(given_args, false, function(key, value) {
       if (!used_args[key]) {
-        keys.push(key);
-        map[key] = given_map[key];
+        Opal.hash_put(map, key, value);
       }
-    }
+      return [false, false];
+    });
 
-    return Opal.hash2(keys, map);
+    return map;
   };
 
   function apply_blockopts(block, blockopts) {
@@ -1866,6 +1860,11 @@
   }
   Opal.jsid = $jsid;
 
+  function $prepend(first, second) {
+    if (!second.$$is_array) second = $slice(second);
+    return [first].concat(second);
+  }
+
   // Calls passed method on a ruby object with arguments and block:
   //
   // Can take a method or a method name.
@@ -1909,7 +1908,7 @@
   Opal.send2 = function(recv, body, method, args, block, blockopts) {
     if (body == null && method != null && recv.$method_missing) {
       body = recv.$method_missing;
-      args = [method].concat(args);
+      args = $prepend(method, args);
     }
 
     apply_blockopts(block, blockopts);
@@ -2065,6 +2064,18 @@
     return Opal.defn(Opal.get_singleton_class(obj), jsid, body);
   };
 
+  // Since JavaScript has no concept of modules, we create proxy classes
+  // called `iclasses` that store copies of methods loaded. We need to
+  // update them if we remove a method.
+  function remove_method_from_iclasses(obj, jsid) {
+    if (obj.$$is_module) {
+      for (var i = 0, iclasses = obj.$$iclasses, length = iclasses.length; i < length; i++) {
+        var iclass = iclasses[i];
+        delete iclass[jsid];
+      }
+    }
+  }
+
   // Called from #remove_method.
   Opal.rdef = function(obj, jsid) {
     if (!$has_own(obj.$$prototype, jsid)) {
@@ -2073,6 +2084,8 @@
 
     delete obj.$$prototype[jsid];
 
+    remove_method_from_iclasses(obj, jsid);
+
     if (obj.$$is_singleton) {
       if (obj.$$prototype.$singleton_method_removed && !obj.$$prototype.$singleton_method_removed.$$stub) {
         obj.$$prototype.$singleton_method_removed(jsid.substr(1));
@@ -2093,6 +2106,8 @@
 
     Opal.add_stub_for(obj.$$prototype, jsid);
 
+    remove_method_from_iclasses(obj, jsid);
+
     if (obj.$$is_singleton) {
       if (obj.$$prototype.$singleton_method_undefined && !obj.$$prototype.$singleton_method_undefined.$$stub) {
         obj.$$prototype.$singleton_method_undefined(jsid.substr(1));
@@ -2152,16 +2167,11 @@
     // We need a wrapper because otherwise properties
     // would be overwritten on the original body.
     alias = function() {
-      var block = alias.$$p, args, i, ii;
-
-      args = new Array(arguments.length);
-      for(i = 0, ii = arguments.length; i < ii; i++) {
-        args[i] = arguments[i];
-      }
+      var block = alias.$$p, i, ii;
 
       alias.$$p = null;
 
-      return Opal.send(this, body, args, block);
+      return Opal.send(this, body, arguments, block);
     };
 
     // Assign the 'length' value with defineProperty because
@@ -2217,228 +2227,169 @@
   // Hashes
   // ------
 
-  Opal.hash_init = function(hash) {
-    hash.$$smap = Object.create(null);
-    hash.$$map  = Object.create(null);
-    hash.$$keys = [];
-  };
+  Opal.hash_init = function (_hash) {
+    console.warn("DEPRECATION: Opal.hash_init is deprecated and is now a no-op.");
+  }
 
   Opal.hash_clone = function(from_hash, to_hash) {
     to_hash.$$none = from_hash.$$none;
     to_hash.$$proc = from_hash.$$proc;
 
-    for (var i = 0, keys = from_hash.$$keys, smap = from_hash.$$smap, len = keys.length, key, value; i < len; i++) {
-      key = keys[i];
-
-      if (key.$$is_string) {
-        value = smap[key];
-      } else {
-        value = key.value;
-        key = key.key;
-      }
-
+    return Opal.hash_each(from_hash, to_hash, function(key, value) {
       Opal.hash_put(to_hash, key, value);
-    }
+      return [false, to_hash];
+    });
   };
 
   Opal.hash_put = function(hash, key, value) {
-    if (key.$$is_string) {
-      if (!$has_own(hash.$$smap, key)) {
-        hash.$$keys.push(key);
-      }
-      hash.$$smap[key] = value;
-      return;
-    }
+    var type = typeof key;
+    if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint") {
+      hash.set(key, value)
+    } else if (key.$$is_string) {
+      hash.set(key.valueOf(), value);
+    } else {
+      if (!hash.$$keys)
+        hash.$$keys = new Map();
 
-    var key_hash, bucket, last_bucket;
-    key_hash = hash.$$by_identity ? Opal.id(key) : key.$hash();
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash()),
+          keys = hash.$$keys;
 
-    if (!$has_own(hash.$$map, key_hash)) {
-      bucket = {key: key, key_hash: key_hash, value: value};
-      hash.$$keys.push(bucket);
-      hash.$$map[key_hash] = bucket;
-      return;
-    }
+      if (!keys.has(key_hash)) {
+        keys.set(key_hash, [key]);
+        hash.set(key, value);
+        return;
+      }
 
-    bucket = hash.$$map[key_hash];
+      var objects = keys.get(key_hash),
+          object;
 
-    while (bucket) {
-      if (key === bucket.key || key['$eql?'](bucket.key)) {
-        last_bucket = undefined;
-        bucket.value = value;
-        break;
+      for (var i=0; i<objects.length; i++) {
+        object = objects[0];
+        if (key === object || key['$eql?'](object)) {
+          hash.set(object, value);
+          return;
+        }
       }
-      last_bucket = bucket;
-      bucket = bucket.next;
-    }
 
-    if (last_bucket) {
-      bucket = {key: key, key_hash: key_hash, value: value};
-      hash.$$keys.push(bucket);
-      last_bucket.next = bucket;
+      objects.push(key);
+      hash.set(key, value);
     }
   };
 
   Opal.hash_get = function(hash, key) {
-    if (key.$$is_string) {
-      if ($has_own(hash.$$smap, key)) {
-        return hash.$$smap[key];
-      }
-      return;
-    }
-
-    var key_hash, bucket;
-    key_hash = hash.$$by_identity ? Opal.id(key) : key.$hash();
-
-    if ($has_own(hash.$$map, key_hash)) {
-      bucket = hash.$$map[key_hash];
-
-      while (bucket) {
-        if (key === bucket.key || key['$eql?'](bucket.key)) {
-          return bucket.value;
+    var type = typeof key;
+    if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint") {
+      return hash.get(key)
+    } else if (hash.$$keys) {
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash()),
+          objects = hash.$$keys.get(key_hash),
+          object;
+
+      if (objects !== undefined) {
+        for (var i=0; i<objects.length; i++) {
+          object = objects[i];
+          if (key === object || key['$eql?'](object))
+            return hash.get(object);
         }
-        bucket = bucket.next;
+      } else if (key.$$is_string) {
+        return hash.get(key_hash);
       }
+    } else if (key.$$is_string) {
+      return hash.get(key.valueOf());
     }
   };
 
-  Opal.hash_delete = function(hash, key) {
-    var i, keys = hash.$$keys, length = keys.length, value, key_tmp;
-
-    if (key.$$is_string) {
-      if (typeof key !== "string") key = key.valueOf();
-
-      if (!$has_own(hash.$$smap, key)) {
-        return;
-      }
-
-      for (i = 0; i < length; i++) {
-        key_tmp = keys[i];
-
-        if (key_tmp.$$is_string && typeof key_tmp !== "string") {
-          key_tmp = key_tmp.valueOf();
-        }
-
-        if (key_tmp === key) {
-          keys.splice(i, 1);
-          break;
-        }
-      }
-
-      value = hash.$$smap[key];
-      delete hash.$$smap[key];
+  function $hash_delete_stage2(hash, key) {
+    var value = hash.get(key);
+    if (value !== undefined) {
+      hash.delete(key);
       return value;
     }
+  }
 
-    var key_hash = key.$hash();
-
-    if (!$has_own(hash.$$map, key_hash)) {
-      return;
-    }
-
-    var bucket = hash.$$map[key_hash], last_bucket;
-
-    while (bucket) {
-      if (key === bucket.key || key['$eql?'](bucket.key)) {
-        value = bucket.value;
-
-        for (i = 0; i < length; i++) {
-          if (keys[i] === bucket) {
-            keys.splice(i, 1);
-            break;
+  Opal.hash_delete = function(hash, key) {
+    var type = typeof key
+    if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint") {
+      return $hash_delete_stage2(hash, key);
+    } else if (hash.$$keys) {
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash()),
+          objects = hash.$$keys.get(key_hash),
+          object;
+
+      if (objects !== undefined) {
+        for (var i=0; i<objects.length; i++) {
+          object = objects[i];
+          if (key === object || key['$eql?'](object)) {
+            objects.splice(i, 1);
+            if (objects.length === 0)
+              hash.$$keys.delete(key_hash);
+            return $hash_delete_stage2(hash, object);
           }
         }
-
-        if (last_bucket && bucket.next) {
-          last_bucket.next = bucket.next;
-        }
-        else if (last_bucket) {
-          delete last_bucket.next;
-        }
-        else if (bucket.next) {
-          hash.$$map[key_hash] = bucket.next;
-        }
-        else {
-          delete hash.$$map[key_hash];
-        }
-
-        return value;
+      } else if (key.$$is_string) {
+        return $hash_delete_stage2(hash, key_hash);
       }
-      last_bucket = bucket;
-      bucket = bucket.next;
+    } else if (key.$$is_string) {
+      return $hash_delete_stage2(hash, key.valueOf());
     }
   };
 
   Opal.hash_rehash = function(hash) {
-    for (var i = 0, length = hash.$$keys.length, key_hash, bucket, last_bucket; i < length; i++) {
+    var keys = hash.$$keys;
 
-      if (hash.$$keys[i].$$is_string) {
-        continue;
-      }
+    if (keys)
+      keys.clear();
 
-      key_hash = hash.$$keys[i].key.$hash();
+    Opal.hash_each(hash, false, function(key, value) {
+      var type = typeof key;
+      if (type === "string" || type === "symbol" || type === "number" || type === "boolean" || type === "bigint")
+        return [false, false]; // nothing to rehash
 
-      if (key_hash === hash.$$keys[i].key_hash) {
-        continue;
-      }
+      var key_hash = key.$$is_string ? key.valueOf() : (hash.$$by_identity ? Opal.id(key) : key.$hash());
 
-      bucket = hash.$$map[hash.$$keys[i].key_hash];
-      last_bucket = undefined;
+      if (!keys)
+        hash.$$keys = keys = new Map();
 
-      while (bucket) {
-        if (bucket === hash.$$keys[i]) {
-          if (last_bucket && bucket.next) {
-            last_bucket.next = bucket.next;
-          }
-          else if (last_bucket) {
-            delete last_bucket.next;
-          }
-          else if (bucket.next) {
-            hash.$$map[hash.$$keys[i].key_hash] = bucket.next;
-          }
-          else {
-            delete hash.$$map[hash.$$keys[i].key_hash];
-          }
-          break;
-        }
-        last_bucket = bucket;
-        bucket = bucket.next;
+      if (!keys.has(key_hash)) {
+        keys.set(key_hash, [key]);
+        return [false, false];
       }
 
-      hash.$$keys[i].key_hash = key_hash;
+      var objects = keys.get(key_hash),
+          objects_copy = $slice(objects),
+          object;
 
-      if (!$has_own(hash.$$map, key_hash)) {
-        hash.$$map[key_hash] = hash.$$keys[i];
-        continue;
+      for (var i=0; i<objects_copy.length; i++) {
+        object = objects_copy[i];
+        if (key === object || key['$eql?'](object)) {
+          // got a duplicate, remove it
+          objects.splice(objects.indexOf(object), 1);
+          hash.delete(object);
+        }
       }
 
-      bucket = hash.$$map[key_hash];
-      last_bucket = undefined;
+      objects.push(key);
 
-      while (bucket) {
-        if (bucket === hash.$$keys[i]) {
-          last_bucket = undefined;
-          break;
-        }
-        last_bucket = bucket;
-        bucket = bucket.next;
-      }
+      return [false, false]
+    });
 
-      if (last_bucket) {
-        last_bucket.next = hash.$$keys[i];
-      }
-    }
+    return hash;
   };
 
-  Opal.hash = function() {
-    var arguments_length = arguments.length, args, hash, i, length, key, value;
+  Opal.hash = function () {
+    var arguments_length = arguments.length,
+      args,
+      hash,
+      i,
+      length,
+      key,
+      value;
 
     if (arguments_length === 1 && arguments[0].$$is_hash) {
       return arguments[0];
     }
 
-    hash = new Opal.Hash();
-    Opal.hash_init(hash);
+    hash = new Map();
 
     if (arguments_length === 1) {
       args = arguments[0];
@@ -2448,7 +2399,7 @@
 
         for (i = 0; i < length; i++) {
           if (args[i].length !== 2) {
-            $raise(Opal.ArgumentError, "value not of length 2: " + args[i].$inspect());
+            $raise(Opal.ArgumentError, 'value not of length 2: ' + args[i].$inspect());
           }
 
           key = args[i][0];
@@ -2458,8 +2409,7 @@
         }
 
         return hash;
-      }
-      else {
+      } else {
         args = arguments[0];
         for (key in args) {
           if ($has_own(args, key)) {
@@ -2474,7 +2424,7 @@
     }
 
     if (arguments_length % 2 !== 0) {
-      $raise(Opal.ArgumentError, "odd number of arguments for Hash");
+      $raise(Opal.ArgumentError, 'odd number of arguments for Hash');
     }
 
     for (i = 0; i < arguments_length; i += 2) {
@@ -2493,15 +2443,29 @@
   // function.
   //
   Opal.hash2 = function(keys, smap) {
-    var hash = new Opal.Hash();
-
-    hash.$$smap = smap;
-    hash.$$map  = Object.create(null);
-    hash.$$keys = keys;
+    console.warn("DEPRECATION: `Opal.hash2` is deprecated and will be removed in Opal 2.0. Use `new Map()` with an array of key/value pairs instead.");
 
+    var hash = new Map();
+    for (var i = 0, max = keys.length; i < max; i++) {
+      hash.set(keys[i], smap[keys[i]]);
+    }
     return hash;
   };
 
+  Opal.hash_each = function (hash, dres, fun) {
+    // dres = default result, returned if hash is empty
+    // fun is called as fun(key, value) and must return a array with [break, result]
+    // if break is true, iteration stops and result is returned
+    // if break is false, iteration continues and eventually the last result is returned
+    var res;
+    for (var i = 0, entry, entries = Array.from(hash.entries()), l = entries.length; i < l; i++) {
+      entry = entries[i];
+      res = fun(entry[0], entry[1]);
+      if (res[0]) return res[1];
+    }
+    return res ? res[1] : dres;
+  };
+
   // Create a new range instance with first and last values, and whether the
   // range excludes the last value.
   //
@@ -2539,7 +2503,7 @@
   // helper that can be used from methods
   function $deny_frozen_access(obj) {
     if (obj.$$frozen) {
-      $raise(Opal.FrozenError, "can't modify frozen " + (obj.$class()) + ": " + (obj), Opal.hash2(["receiver"], {"receiver": obj}));
+      $raise(Opal.FrozenError, "can't modify frozen " + (obj.$class()) + ": " + (obj), new Map([["receiver", obj]]));
     }
   };
   Opal.deny_frozen_access = $deny_frozen_access;
@@ -2664,7 +2628,7 @@
         if (part.ignoreCase !== ignoreCase)
           Opal.Kernel.$warn(
             "ignore case doesn't match for " + part.source.$inspect(),
-            Opal.hash({uplevel: 1})
+            new Map([['uplevel',  1]])
           )
 
         part = part.source;
@@ -2915,7 +2879,7 @@
   // Primitives for handling parameters
   Opal.ensure_kwargs = function(kwargs) {
     if (kwargs == null) {
-      return Opal.hash2([], {});
+      return new Map();
     } else if (kwargs.$$is_hash) {
       return kwargs;
     } else {
@@ -2924,10 +2888,11 @@
   }
 
   Opal.get_kwarg = function(kwargs, key) {
-    if (!$has_own(kwargs.$$smap, key)) {
+    var kwarg = Opal.hash_get(kwargs, key);
+    if (kwarg === undefined) {
       $raise(Opal.ArgumentError, 'missing keyword: '+key);
     }
-    return kwargs.$$smap[key];
+    return kwarg;
   }
 
   // Arrays of size > 32 elements that contain only strings,
@@ -3012,10 +2977,9 @@
 
   // Foward calls to define_method on the top object to Object
   function top_define_method() {
-    var args = $slice(arguments);
     var block = top_define_method.$$p;
     top_define_method.$$p = null;
-    return Opal.send(_Object, 'define_method', args, block)
+    return Opal.send(_Object, 'define_method', arguments, block)
   };
 
   // Nil
@@ -3029,7 +2993,7 @@
   Object.seal(nil);
 
   Opal.thrower = function(type) {
-    var thrower = new Error('unexpected '+type);
+    var thrower = { message: 'unexpected '+type };
     thrower.$thrower_type = type;
     thrower.$throw = function(value) {
       if (value == null) value = nil;

data/opal/corelib/set.rb

@@ -1,4 +1,6 @@
 # helpers: freeze
+# backtick_javascript: true
+
 # Portions Copyright (c) 2002-2013 Akinori MUSHA <knu@iDaemons.org>
 class ::Set
   include ::Enumerable

data/opal/corelib/string/encoding.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/string'
 
 class ::Encoding
@@ -103,6 +105,7 @@ class ::Encoding
 
   class ::EncodingError < ::StandardError; end
   class ::CompatibilityError < ::EncodingError; end
+  class UndefinedConversionError < ::EncodingError; end
 end
 
 ::Encoding.register 'UTF-8', aliases: ['CP65001'], ascii: true do

data/opal/corelib/string/unpack.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'base64'
 require 'corelib/pack_unpack/format_string_parser'