opal 0.9.4 → 0.10.0.beta1

data/lib/opal/version.rb

@@ -1,5 +1,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '0.9.4'
+  VERSION = '0.10.0.beta1'
 end

data/opal.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'yard', '~> 0.8.7'
   s.add_development_dependency 'rack-test'
   s.add_development_dependency 'opal-minitest'
+  s.add_development_dependency 'coveralls'
 end

data/opal/corelib/array.rb

@@ -7,8 +7,18 @@ class Array < `Array`
   # Mark all javascript arrays as being valid ruby arrays
   `def.$$is_array = true`
 
+  %x{
+    function toArraySubclass(obj, klass) {
+      if (klass.$$name === Opal.Array) {
+        return obj;
+      } else {
+        return klass.$allocate().$replace(#{`obj`.to_a});
+      }
+    }
+  }
+
   def self.[](*objects)
-    objects
+    `toArraySubclass(objects, self)`
   end
 
   def initialize(size = nil, obj = nil, &block)
@@ -25,9 +35,11 @@ class Array < `Array`
 
     if `arguments.length === 1`
       if Array === size
-        return size.to_a
+        replace(size.to_a)
+        return self
       elsif size.respond_to? :to_ary
-        return size.to_ary
+        replace(size.to_ary)
+        return self
       end
     end
 
@@ -49,11 +61,6 @@ class Array < `Array`
       else {
         for (i = 0, value; i < size; i++) {
           value = block(i);
-
-          if (value === $breaker) {
-            return $breaker.$v;
-          }
-
           self[i] = value;
         }
       }
@@ -62,10 +69,6 @@ class Array < `Array`
     }
   end
 
-  def self.new(*args, &block)
-    [].initialize(*args, &block)
-  end
-
   def self.try_convert(obj)
     Opal.coerce_to? obj, Array, :to_ary
   end
@@ -120,10 +123,6 @@ class Array < `Array`
   def *(other)
     return join(other.to_str) if other.respond_to? :to_str
 
-    unless other.respond_to? :to_int
-      raise TypeError, "no implicit conversion of #{other.class} into Integer"
-    end
-
     other = Opal.coerce_to other, Integer, :to_int
 
     if `other < 0`
@@ -131,13 +130,14 @@ class Array < `Array`
     end
 
     %x{
-      var result = [];
+      var result = [],
+          converted = #{self.to_a};
 
       for (var i = 0; i < other; i++) {
-        result = result.concat(self);
+        result = result.concat(converted);
       }
 
-      return result;
+      return toArraySubclass(result, #{self.class});
     }
   end
 
@@ -159,7 +159,7 @@ class Array < `Array`
     end
 
     return [] if `self.length === 0`
-    return clone if `other.length === 0`
+    return clone.to_a if `other.length === 0`
 
     %x{
       var result = [], hash = #{{}}, i, length, item;
@@ -232,9 +232,9 @@ class Array < `Array`
         }
 
         if (array.constructor !== Array)
-          array = array.literal;
+          array = #{`array`.to_a};
         if (other.constructor !== Array)
-          other = other.literal;
+          other = #{`other`.to_a};
 
         if (array.length !== other.length) {
           return false;
@@ -271,7 +271,7 @@ class Array < `Array`
   def [](index, length = undefined)
     %x{
       var size = self.length,
-          exclude, from, to;
+          exclude, from, to, result;
 
       if (index.$$is_range) {
         exclude = index.exclude;
@@ -302,7 +302,7 @@ class Array < `Array`
           to += 1;
         }
 
-        return self.slice(from, to);
+        result = self.slice(from, to)
       }
       else {
         index = #{Opal.coerce_to(index, Integer, :to_int)};
@@ -329,9 +329,11 @@ class Array < `Array`
             return nil;
           }
 
-          return self.slice(index, index + length);
+          result = self.slice(index, index + length);
         }
       }
+
+      return toArraySubclass(result, #{self.class})
     }
   end
 
@@ -483,10 +485,7 @@ class Array < `Array`
         val = self[mid];
         ret = block(val);
 
-        if (ret === $breaker) {
-          return $breaker.$v;
-        }
-        else if (ret === true) {
+        if (ret === true) {
           satisfied = val;
           smaller = true;
         }
@@ -527,10 +526,6 @@ class Array < `Array`
         while (true) {
           for (i = 0, length = self.length; i < length; i++) {
             value = Opal.yield1(block, self[i]);
-
-            if (value === $breaker) {
-              return $breaker.$v;
-            }
           }
         }
       }
@@ -543,10 +538,6 @@ class Array < `Array`
         while (n > 0) {
           for (i = 0, length = self.length; i < length; i++) {
             value = Opal.yield1(block, self[i]);
-
-            if (value === $breaker) {
-              return $breaker.$v;
-            }
           }
 
           n--;
@@ -563,19 +554,6 @@ class Array < `Array`
     self
   end
 
-  def clone
-    copy = []
-    copy.copy_singleton_methods(self)
-    copy.initialize_clone(self)
-    copy
-  end
-
-  def dup
-    copy = []
-    copy.initialize_dup(self)
-    copy
-  end
-
   def initialize_copy(other)
     replace other
   end
@@ -588,11 +566,6 @@ class Array < `Array`
 
       for (var i = 0, length = self.length; i < length; i++) {
         var value = Opal.yield1(block, self[i]);
-
-        if (value === $breaker) {
-          return $breaker.$v;
-        }
-
         result.push(value);
       }
 
@@ -606,11 +579,6 @@ class Array < `Array`
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
         var value = Opal.yield1(block, self[i]);
-
-        if (value === $breaker) {
-          return $breaker.$v;
-        }
-
         self[i] = value;
       }
     }
@@ -680,6 +648,34 @@ class Array < `Array`
     self
   end
 
+  def repeated_combination(n)
+    num = Opal.coerce_to! n, Integer, :to_int
+
+    unless block_given?
+      return enum_for(:repeated_combination, num){ `binomial_coefficient(self.length + num - 1, num)` }
+    end
+
+    %x{
+      function iterate(max, from, buffer, self) {
+        if (buffer.length == max) {
+          var copy = buffer.slice();
+          #{yield `copy`}
+          return;
+        }
+        for (var i = from; i < self.length; i++) {
+          buffer.push(self[i]);
+          iterate(max, i, buffer, self);
+          buffer.pop();
+        }
+      }
+
+      if (num >= 0) {
+        iterate(num, 0, [], self);
+      }
+    }
+    self
+  end
+
   def compact
     %x{
       var result = [];
@@ -775,9 +771,7 @@ class Array < `Array`
 
     %x{
       for (var i = 0, length = self.length, value; i < length; i++) {
-        if ((value = block(self[i])) === $breaker) {
-          return $breaker.$v;
-        }
+        value = block(self[i]);
 
         if (value !== false && value !== nil) {
           self.splice(i, 1);
@@ -807,10 +801,6 @@ class Array < `Array`
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
         var value = Opal.yield1(block, self[i]);
-
-        if (value == $breaker) {
-          return $breaker.$v;
-        }
       }
     }
 
@@ -823,10 +813,6 @@ class Array < `Array`
     %x{
       for (var i = 0, length = self.length; i < length; i++) {
         var value = Opal.yield1(block, i);
-
-        if (value === $breaker) {
-          return $breaker.$v;
-        }
       }
     }
 
@@ -981,11 +967,6 @@ class Array < `Array`
       %x{
         for (length = #@length; left < right; left++) {
           value = block(left);
-
-          if (value === $breaker) {
-            return $breaker.$v;
-          }
-
           self[left] = value;
         }
       }
@@ -1050,7 +1031,7 @@ class Array < `Array`
 
           switch (level) {
           case undefined:
-            result.push.apply(result, _flatten(ary));
+            result = result.concat(_flatten(ary));
             break;
           case 0:
             result.push(ary);
@@ -1066,7 +1047,7 @@ class Array < `Array`
         level = #{Opal.coerce_to(`level`, Integer, :to_int)};
       }
 
-      return _flatten(self, level);
+      return toArraySubclass(_flatten(self, level), #{self.class});
     }
   end
 
@@ -1158,9 +1139,7 @@ class Array < `Array`
       }
       else if (block !== nil) {
         for (i = 0, length = self.length; i < length; i++) {
-          if ((value = block(self[i])) === $breaker) {
-            return $breaker.$v;
-          }
+          value = block(self[i]);
 
           if (value !== false && value !== nil) {
             return i;
@@ -1285,9 +1264,7 @@ class Array < `Array`
 
     %x{
       for (var i = 0, length = self.length, value; i < length; i++) {
-        if ((value = block(self[i])) === $breaker) {
-          return $breaker.$v;
-        }
+        value = block(self[i]);
 
         if (value === false || value === nil) {
           self.splice(i, 1);
@@ -1329,8 +1306,23 @@ class Array < `Array`
 
   alias map! collect!
 
+  %x{
+    // Returns the product of from, from-1, ..., from - how_many + 1.
+    function descending_factorial(from, how_many) {
+      var count = how_many >= 0 ? 1 : 0;
+      while (how_many) {
+        count *= from;
+        from--;
+        how_many--;
+      }
+      return count;
+    }
+  }
+
   def permutation(num = undefined, &block)
-    return enum_for(:permutation, num){self.size} unless block_given?
+    unless block_given?
+      return enum_for(:permutation, num){ `descending_factorial(self.length, num === undefined ? self.length : num)` }
+    end
 
     %x{
       var permute, offensive, output;
@@ -1395,6 +1387,30 @@ class Array < `Array`
     self
   end
 
+  def repeated_permutation(n)
+    num = Opal.coerce_to! n, Integer, :to_int
+    return enum_for(:repeated_permutation, num){ num >= 0 ? self.size ** num : 0 } unless block_given?
+
+    %x{
+      function iterate(max, buffer, self) {
+        if (buffer.length == max) {
+          var copy = buffer.slice();
+          #{yield `copy`}
+          return;
+        }
+        for (var i = 0; i < self.length; i++) {
+          buffer.push(self[i]);
+          iterate(max, buffer, self);
+          buffer.pop();
+        }
+      }
+
+      iterate(num, [], self.slice());
+    }
+
+    self
+  end
+
   def pop(count = undefined)
     if `count === undefined`
       return if `self.length === 0`
@@ -1499,9 +1515,7 @@ class Array < `Array`
       var result = [];
 
       for (var i = 0, length = self.length, value; i < length; i++) {
-        if ((value = block(self[i])) === $breaker) {
-          return $breaker.$v;
-        }
+        value = block(self[i]);
 
         if (value === false || value === nil) {
           result.push(self[i]);
@@ -1571,9 +1585,9 @@ class Array < `Array`
           if (i >= self.length) {
             break;
           }
-          if ((value = block(self[i])) === $breaker) {
-            return $breaker.$v;
-          }
+
+          value = block(self[i]);
+
           if (value !== false && value !== nil) {
             return i;
           }
@@ -1753,9 +1767,7 @@ class Array < `Array`
       for (var i = 0, length = self.length, item, value; i < length; i++) {
         item = self[i];
 
-        if ((value = Opal.yield1(block, item)) === $breaker) {
-          return $breaker.$v;
-        }
+        value = Opal.yield1(block, item);
 
         if (value !== false && value !== nil) {
           result.push(item);
@@ -1796,7 +1808,7 @@ class Array < `Array`
   alias size length
 
   def shuffle(rng = undefined)
-    dup.shuffle!(rng)
+    dup.to_a.shuffle!(rng)
   end
 
   def shuffle!(rng = undefined)
@@ -1843,21 +1855,88 @@ class Array < `Array`
   alias slice []
 
   def slice!(index, length = undefined)
-    %x{
-      if (index < 0) {
-        index += self.length;
-      }
+    result = nil
 
-      if (length != null) {
-        return self.splice(index, length);
-      }
+    if `length === undefined`
+      if Range === index
+        range = index
+        result = self[range]
 
-      if (index < 0 || index >= self.length) {
-        return nil;
-      }
+        range_start = Opal.coerce_to(range.begin, Integer, :to_int)
+        range_end = Opal.coerce_to(range.end, Integer, :to_int)
 
-      return self.splice(index, 1)[0];
-    }
+        %x{
+          if (range_start < 0) {
+            range_start += self.length;
+          }
+
+          if (range_end < 0) {
+            range_end += self.length;
+          } else if (range_end >= self.length) {
+            range_end = self.length - 1;
+            if (range.exclude) {
+              range_end += 1;
+            }
+          }
+
+          var range_length = range_end - range_start;
+          if (range.exclude) {
+            range_end -= 1;
+          } else {
+            range_length += 1;
+          }
+
+          if (range_start < self.length && range_start >= 0 && range_end < self.length && range_end >= 0 && range_length > 0) {
+            self.splice(range_start, range_length);
+          }
+        }
+      else
+        start = Opal.coerce_to(index, Integer, :to_int)
+        %x{
+          if (start < 0) {
+            start += self.length;
+          }
+
+          if (start < 0 || start >= self.length) {
+            return nil;
+          }
+
+          result = self[start];
+
+          if (start === 0) {
+            self.shift();
+          } else {
+            self.splice(start, 1);
+          }
+        }
+      end
+    else
+      start = Opal.coerce_to(index, Integer, :to_int)
+      length = Opal.coerce_to(length, Integer, :to_int)
+
+      %x{
+        if (length < 0) {
+          return nil;
+        }
+
+        var end = start + length;
+
+        result = #{self[start, length]};
+
+        if (start < 0) {
+          start += self.length;
+        }
+
+        if (start + length > self.length) {
+          length = self.length - start;
+        }
+
+        if (start < self.length && start >= 0) {
+          self.splice(start, length);
+        }
+      }
+    end
+    result
   end
 
   def sort(&block)
@@ -1870,28 +1949,15 @@ class Array < `Array`
         };
       }
 
-      try {
-        return self.slice().sort(function(x, y) {
-          var ret = block(x, y);
+      return self.slice().sort(function(x, y) {
+        var ret = block(x, y);
 
-          if (ret === $breaker) {
-            throw $breaker;
-          }
-          else if (ret === nil) {
-            #{raise ArgumentError, "comparison of #{`x`.inspect} with #{`y`.inspect} failed"};
-          }
-
-          return #{`ret` > 0} ? 1 : (#{`ret` < 0} ? -1 : 0);
-        });
-      }
-      catch (e) {
-        if (e === $breaker) {
-          return $breaker.$v;
+        if (ret === nil) {
+          #{raise ArgumentError, "comparison of #{`x`.inspect} with #{`y`.inspect} failed"};
         }
-        else {
-          throw e;
-        }
-      }
+
+        return #{`ret` > 0} ? 1 : (#{`ret` < 0} ? -1 : 0);
+      });
     }
   end
 
@@ -1915,6 +1981,12 @@ class Array < `Array`
     }
   end
 
+  def sort_by!(&block)
+    return enum_for(:sort_by!){self.size} unless block_given?
+
+    replace sort_by(&block)
+  end
+
   def take(count)
     %x{
       if (count < 0) {
@@ -1932,9 +2004,7 @@ class Array < `Array`
       for (var i = 0, length = self.length, item, value; i < length; i++) {
         item = self[i];
 
-        if ((value = block(item)) === $breaker) {
-          return $breaker.$v;
-        }
+        value = block(item);
 
         if (value === false || value === nil) {
           return result;
@@ -2026,7 +2096,7 @@ class Array < `Array`
         }
       }
 
-      return hash.$values();
+      return toArraySubclass(#{`hash`.values}, #{self.class});
     }
   end
 
@@ -2149,4 +2219,12 @@ class Array < `Array`
       return result;
     }
   end
+
+  def self.inherited(klass)
+    %x{
+      klass.$$proto.$to_a = function() {
+        return this.slice(0, this.length);
+      }
+    }
+  end
 end