opal 0.10.0 → 0.11.0

data/opal/corelib/array.rb

@@ -22,34 +22,40 @@ class Array < `Array`
   end
 
   def initialize(size = nil, obj = nil, &block)
-    if `arguments.length > 2`
-      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..2)"
-    end
-
     %x{
+      if (obj !== nil && block !== nil) {
+        #{warn('warning: block supersedes default value argument')}
+      }
+
+      if (size > #{Integer::MAX}) {
+        #{raise ArgumentError, "array size too big"}
+      }
+
+      if (arguments.length > 2) {
+        #{raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 0..2)"}
+      }
+
       if (arguments.length === 0) {
         self.splice(0, self.length);
         return self;
       }
-    }
 
-    if `arguments.length === 1`
-      if Array === size
-        replace(size.to_a)
-        return self
-      elsif size.respond_to? :to_ary
-        replace(size.to_ary)
-        return self
-      end
-    end
+      if (arguments.length === 1) {
+        if (size.$$is_array) {
+          #{replace(size.to_a)}
+          return self;
+        } else if (#{size.respond_to? :to_ary}) {
+          #{replace(size.to_ary)}
+          return self;
+        }
+      }
 
-    size = Opal.coerce_to size, Integer, :to_int
+      size = #{Opal.coerce_to size, Integer, :to_int}
 
-    if `size < 0`
-      raise ArgumentError, "negative array size"
-    end
+      if (size < 0) {
+        #{raise ArgumentError, "negative array size"}
+      }
 
-    %x{
       self.splice(0, self.length);
       var i, value;
 
@@ -159,7 +165,7 @@ class Array < `Array`
     end
 
     return [] if `self.length === 0`
-    return clone.to_a if `other.length === 0`
+    return `self.slice()` if `other.length === 0`
 
     %x{
       var result = [], hash = #{{}}, i, length, item;
@@ -268,72 +274,85 @@ class Array < `Array`
     }
   end
 
-  def [](index, length = undefined)
-    %x{
+  %x{
+    function $array_slice_range(self, index) {
       var size = self.length,
           exclude, from, to, result;
 
-      if (index.$$is_range) {
-        exclude = index.exclude;
-        from    = #{Opal.coerce_to `index.begin`, Integer, :to_int};
-        to      = #{Opal.coerce_to `index.end`, Integer, :to_int};
-
-        if (from < 0) {
-          from += size;
+      exclude = index.excl;
+      from    = Opal.Opal.$coerce_to(index.begin, Opal.Integer, 'to_int');
+      to      = Opal.Opal.$coerce_to(index.end, Opal.Integer, 'to_int');
 
-          if (from < 0) {
-            return nil;
-          }
-        }
+      if (from < 0) {
+        from += size;
 
-        if (from > size) {
+        if (from < 0) {
           return nil;
         }
+      }
 
-        if (to < 0) {
-          to += size;
+      if (from > size) {
+        return nil;
+      }
 
-          if (to < 0) {
-            return [];
-          }
-        }
+      if (to < 0) {
+        to += size;
 
-        if (!exclude) {
-          to += 1;
+        if (to < 0) {
+          return [];
         }
+      }
 
-        result = self.slice(from, to)
+      if (!exclude) {
+        to += 1;
       }
-      else {
-        index = #{Opal.coerce_to(index, Integer, :to_int)};
 
-        if (index < 0) {
-          index += size;
+      result = self.slice(from, to);
+      return toArraySubclass(result, self.$class());
+    }
 
-          if (index < 0) {
-            return nil;
-          }
-        }
+    function $array_slice_index_length(self, index, length) {
+      var size = self.length,
+          exclude, from, to, result;
 
-        if (length === undefined) {
-          if (index >= size || index < 0) {
-            return nil;
-          }
+      index = Opal.Opal.$coerce_to(index, Opal.Integer, 'to_int');
 
-          return self[index];
+      if (index < 0) {
+        index += size;
+
+        if (index < 0) {
+          return nil;
         }
-        else {
-          length = #{Opal.coerce_to length, Integer, :to_int};
+      }
 
-          if (length < 0 || index > size || index < 0) {
-            return nil;
-          }
+      if (length === undefined) {
+        if (index >= size || index < 0) {
+          return nil;
+        }
+
+        return self[index];
+      }
+      else {
+        length = Opal.Opal.$coerce_to(length, Opal.Integer, 'to_int');
 
-          result = self.slice(index, index + length);
+        if (length < 0 || index > size || index < 0) {
+          return nil;
         }
+
+        result = self.slice(index, index + length);
       }
+      return toArraySubclass(result, self.$class());
+    }
+  }
 
-      return toArraySubclass(result, #{self.class})
+  def [](index, length = undefined)
+    %x{
+      if (index.$$is_range) {
+        return $array_slice_range(self, index);
+      }
+      else {
+        return $array_slice_index_length(self, index, length);
+      }
     }
   end
 
@@ -352,7 +371,7 @@ class Array < `Array`
       end
 
       %x{
-        var exclude = index.exclude,
+        var exclude = index.excl,
             from    = #{Opal.coerce_to `index.begin`, Integer, :to_int},
             to      = #{Opal.coerce_to `index.end`, Integer, :to_int};
 
@@ -440,6 +459,11 @@ class Array < `Array`
     end
   end
 
+  def any?
+    `if (self.length === 0) return false;`
+    super
+  end
+
   def assoc(object)
     %x{
       for (var i = 0, length = self.length, item; i < length; i++) {
@@ -468,8 +492,8 @@ class Array < `Array`
     }
   end
 
-  def bsearch(&block)
-    return enum_for :bsearch unless block_given?
+  def bsearch_index(&block)
+    return enum_for :bsearch_index unless block_given?
 
     %x{
       var min = 0,
@@ -483,17 +507,17 @@ class Array < `Array`
       while (min < max) {
         mid = min + Math.floor((max - min) / 2);
         val = self[mid];
-        ret = block(val);
+        ret = Opal.yield1(block, val);
 
         if (ret === true) {
-          satisfied = val;
+          satisfied = mid;
           smaller = true;
         }
         else if (ret === false || ret === nil) {
           smaller = false;
         }
         else if (ret.$$is_number) {
-          if (ret === 0) { return val; }
+          if (ret === 0) { return mid; }
           smaller = (ret < 0);
         }
         else {
@@ -507,6 +531,20 @@ class Array < `Array`
     }
   end
 
+  def bsearch(&block)
+    return enum_for :bsearch unless block_given?
+
+    index = bsearch_index(&block)
+
+    %x{
+      if (index != null && index.$$is_number) {
+        return self[index];
+      } else {
+        return index;
+      }
+    }
+  end
+
   def cycle(n = nil, &block)
     return enum_for(:cycle, n) {
       if n == nil
@@ -715,18 +753,28 @@ class Array < `Array`
     }
   end
 
-  def concat(other)
-    if Array === other
-      other = other.to_a
-    else
-      other = Opal.coerce_to(other, Array, :to_ary).to_a
+  def concat(*others)
+    others = others.map do |other|
+      if Array === other
+        other = other.to_a
+      else
+        other = Opal.coerce_to(other, Array, :to_ary).to_a
+      end
+
+      if other.equal?(self)
+        other = other.dup
+      end
+
+      other
     end
 
-    %x{
-      for (var i = 0, length = other.length; i < length; i++) {
-        self.push(other[i]);
+    others.each do |other|
+      %x{
+        for (var i = 0, length = other.length; i < length; i++) {
+          self.push(other[i]);
+        }
       }
-    }
+    end
 
     self
   end
@@ -793,6 +841,22 @@ class Array < `Array`
     self
   end
 
+  def dig(idx, *idxs)
+    item = self[idx]
+
+    %x{
+      if (item === nil || idxs.length === 0) {
+        return item;
+      }
+    }
+
+    unless item.respond_to?(:dig)
+      raise TypeError, "#{item.class} does not have #dig method"
+    end
+
+    item.dig(*idxs)
+  end
+
   def drop(number)
     %x{
       if (number < 0) {
@@ -903,6 +967,10 @@ class Array < `Array`
         return self[index];
       }
 
+      if (block !== nil && defaults != null) {
+        #{warn('warning: block supersedes default value argument')}
+      }
+
       if (block !== nil) {
         return block(original);
       }
@@ -945,17 +1013,17 @@ class Array < `Array`
       raise TypeError, "length invalid with range" if two
 
       left   = Opal.coerce_to one.begin, Integer, :to_int
-      `left += #@length` if `left < 0`
+      `left += this.length` if `left < 0`
       raise RangeError, "#{one.inspect} out of range" if `left < 0`
 
       right  = Opal.coerce_to one.end, Integer, :to_int
-      `right += #@length` if `right < 0`
+      `right += this.length` if `right < 0`
       `right += 1` unless one.exclude_end?
 
       return self if `right <= left`
     elsif one
       left   = Opal.coerce_to one, Integer, :to_int
-      `left += #@length` if `left < 0`
+      `left += this.length` if `left < 0`
       left   = 0 if `left < 0`
 
       if two
@@ -965,35 +1033,35 @@ class Array < `Array`
 
         `right += left`
       else
-        right = @length
+        right = `this.length`
       end
     else
       left  = 0
-      right = @length
+      right = `this.length`
     end
 
-    if `left > #@length`
+    if `left > this.length`
       %x{
-        for (i = #@length; i < right; i++) {
+        for (i = this.length; i < right; i++) {
           self[i] = nil;
         }
       }
     end
 
-    if `right > #@length`
-      @length = right
+    if `right > this.length`
+      `this.length = right`
     end
 
     if block
       %x{
-        for (length = #@length; left < right; left++) {
+        for (length = this.length; left < right; left++) {
           value = block(left);
           self[left] = value;
         }
       }
     else
       %x{
-        for (length = #@length; left < right; left++) {
+        for (length = this.length; left < right; left++) {
           self[left] = #{obj};
         }
       }
@@ -1096,26 +1164,25 @@ class Array < `Array`
 
   def hash
     %x{
-      var top = (Opal.hash_ids == undefined),
+      var top = (Opal.hash_ids === undefined),
           result = ['A'],
           hash_id = self.$object_id(),
           item, i, key;
 
       try {
         if (top) {
-          Opal.hash_ids = {};
+          Opal.hash_ids = Object.create(null);
         }
 
-        if (Opal.hash_ids.hasOwnProperty(hash_id)) {
+        // return early for recursive structures
+        if (Opal.hash_ids[hash_id]) {
           return 'self';
         }
 
         for (key in Opal.hash_ids) {
-          if (Opal.hash_ids.hasOwnProperty(key)) {
-            item = Opal.hash_ids[key];
-            if (#{eql?(`item`)}) {
-              return 'self';
-            }
+          item = Opal.hash_ids[key];
+          if (#{eql?(`item`)}) {
+            return 'self';
           }
         }
 
@@ -1129,7 +1196,7 @@ class Array < `Array`
         return result.join(',');
       } finally {
         if (top) {
-          delete Opal.hash_ids;
+          Opal.hash_ids = undefined;
         }
       }
     }
@@ -1151,6 +1218,10 @@ class Array < `Array`
     %x{
       var i, length, value;
 
+      if (object != null && block !== nil) {
+        #{warn('warning: given block not used')}
+      }
+
       if (object != null) {
         for (i = 0, length = self.length; i < length; i++) {
           if (#{`self[i]` == object}) {
@@ -1268,7 +1339,7 @@ class Array < `Array`
           }
         }
 
-        #{raise NoMethodError.new("#{Opal.inspect(`item`)} doesn't respond to #to_str, #to_ary or #to_s", 'to_str')};
+        #{raise NoMethodError.new("#{`Opal.inspect(item)`} doesn't respond to #to_str, #to_ary or #to_s", 'to_str')};
       }
 
       if (sep === nil) {
@@ -1342,7 +1413,9 @@ class Array < `Array`
 
   def permutation(num = undefined, &block)
     unless block_given?
-      return enum_for(:permutation, num){ `descending_factorial(self.length, num === undefined ? self.length : num)` }
+      return enum_for(:permutation, num) {
+        `descending_factorial(self.length, num === undefined ? self.length : num)`
+      }
     end
 
     %x{
@@ -1370,8 +1443,8 @@ class Array < `Array`
       }
       else {
         // this is the general case
-        #{ perm = Array.new(num) }
-        #{ used = Array.new(`self.length`, false) }
+        #{ perm = Array.new(num) };
+        #{ used = Array.new(`self.length`, false) };
 
         permute = function(num, perm, index, used, blk) {
           self = this;
@@ -1583,7 +1656,7 @@ class Array < `Array`
   def reverse_each(&block)
     return enum_for(:reverse_each){self.size} unless block_given?
 
-    reverse.each &block
+    reverse.each(&block)
     self
   end
 
@@ -1591,6 +1664,10 @@ class Array < `Array`
     %x{
       var i, value;
 
+      if (object != null && block !== nil) {
+        #{warn('warning: given block not used')}
+      }
+
       if (object != null) {
         for (i = self.length - 1; i >= 0; i--) {
           if (i >= self.length) {
@@ -1804,7 +1881,7 @@ class Array < `Array`
 
     %x{
       var original = self.length;
-      #{ keep_if &block };
+      #{ keep_if(&block) };
       return self.length === original ? nil : self;
     }
   end
@@ -1861,7 +1938,7 @@ class Array < `Array`
           }
         }
         else {
-          j = Math.floor(Math.random() * i);
+          j = #{rand(`i`)};
         }
 
         tmp = self[--i];
@@ -1895,13 +1972,13 @@ class Array < `Array`
             range_end += self.length;
           } else if (range_end >= self.length) {
             range_end = self.length - 1;
-            if (range.exclude) {
+            if (range.excl) {
               range_end += 1;
             }
           }
 
           var range_length = range_end - range_start;
-          if (range.exclude) {
+          if (range.excl) {
             range_end -= 1;
           } else {
             range_length += 1;

data/opal/corelib/basic_object.rb

@@ -48,13 +48,13 @@ class BasicObject
 
   def instance_eval(*args, &block)
     if block.nil? && `!!Opal.compile`
-      Kernel.raise ArgumentError, "wrong number of arguments (0 for 1..3)" unless (1..3).cover? args.size
+      ::Kernel.raise ::ArgumentError, "wrong number of arguments (0 for 1..3)" unless (1..3).cover? args.size
 
       string, file, _lineno = *args
       default_eval_options = { file: (file || '(eval)'), eval: true }
       compiling_options = __OPAL_COMPILER_CONFIG__.merge(default_eval_options)
-      compiled = Opal.compile string, compiling_options
-      block = Kernel.proc do
+      compiled = ::Opal.compile string, compiling_options
+      block = ::Kernel.proc do
         %x{
           return (function(self) {
             return eval(compiled);
@@ -62,7 +62,7 @@ class BasicObject
         }
       end
     elsif args.size > 0
-      Kernel.raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
+      ::Kernel.raise ::ArgumentError, "wrong number of arguments (#{args.size} for 0)"
     end
 
     %x{
@@ -94,7 +94,7 @@ class BasicObject
   end
 
   def instance_exec(*args, &block)
-    Kernel.raise ArgumentError, "no block given" unless block
+    ::Kernel.raise ::ArgumentError, "no block given" unless block
 
     %x{
       var block_self = block.$$s,
@@ -131,7 +131,7 @@ class BasicObject
   end
 
   def method_missing(symbol, *args, &block)
-    Kernel.raise NoMethodError.new(`self.$inspect && !self.$inspect.$$stub` ?
+    ::Kernel.raise ::NoMethodError.new(`self.$inspect && !self.$inspect.$$stub` ?
       "undefined method `#{symbol}' for #{inspect}:#{`self.$$class`}" :
       "undefined method `#{symbol}' for #{`self.$$class`}", symbol)
   end

data/opal/corelib/boolean.rb

@@ -2,6 +2,14 @@ class Boolean < `Boolean`
   `def.$$is_boolean = true`
   `def.$$meta = #{self}`
 
+  class << self
+    def allocate
+      raise TypeError, "allocator undefined for #{self.name}"
+    end
+
+    undef :new
+  end
+
   def __id__
     `self.valueOf() ? 2 : 0`
   end
@@ -40,11 +48,11 @@ class Boolean < `Boolean`
   end
 
   def dup
-    raise TypeError, "can't dup #{self.class}"
+    self
   end
 
-  def clone
-    raise TypeError, "can't clone #{self.class}"
+  def clone(freeze: true)
+    self
   end
 end
 

data/opal/corelib/class.rb

@@ -7,15 +7,12 @@ class Class
         throw Opal.TypeError.$new("superclass must be a Class");
       }
 
-      var alloc = Opal.boot_class_alloc(null, function(){}, superclass)
+      var alloc = Opal.boot_class_alloc(null, function(){}, superclass);
       var klass = Opal.setup_class_object(null, alloc, superclass.$$name, superclass.constructor);
 
-      klass.$$super = superclass;
+      klass.$$super  = superclass;
       klass.$$parent = superclass;
 
-      // inherit scope from parent
-      Opal.create_scope(superclass.$$scope, klass);
-
       superclass.$inherited(klass);
       Opal.module_initialize(klass, block);
 
@@ -34,13 +31,19 @@ class Class
   def inherited(cls)
   end
 
-  def new(*args, &block)
+  def initialize_dup(original)
+    initialize_copy(original)
     %x{
-      var obj = #{allocate};
+      self.$$name = null;
+      self.$$full_name = null;
+    }
+  end
 
-      obj.$initialize.$$p = block;
-      obj.$initialize.apply(obj, args);
-      return obj;
+  def new(*args, &block)
+    %x{
+      var object = #{allocate};
+      Opal.send(object, object.$initialize, args, block);
+      return object;
     }
   end
 
@@ -57,7 +60,7 @@ class Class
       }
       else if (singleton_of) {
         // a singleton class created from an object
-        return #{"#<Class:#<#{`singleton_of.$$class`.name}:0x#{`singleton_of.$$id`.to_s(16)}>>"};
+        return #{"#<Class:#<#{`singleton_of.$$class`.name}:0x#{`Opal.id(singleton_of)`.to_s(16)}>>"};
       }
       return #{super()};
     }

data/opal/corelib/comparable.rb

@@ -66,4 +66,20 @@ module Comparable
     return false if self > max
     return true
   end
+
+  def clamp(min, max)
+    cmp = min <=> max
+
+    unless cmp
+      raise ArgumentError, "comparison of #{min.class} with #{max.class} failed"
+    end
+
+    if Comparable.normalize(cmp) > 0
+      raise ArgumentError, 'min argument must be smaller than max argument'
+    end
+
+    return min if Comparable.normalize(self <=> min) < 0
+    return max if Comparable.normalize(self <=> max) > 0
+    return self
+  end
 end