opal 0.5.2 → 0.5.4

data/lib/opal/parser/sexp.rb

@@ -54,7 +54,7 @@ module Opal
     alias eql? ==
 
     def inspect
-      "s(#{@array.map { |e| e.inspect }.join ', '})"
+      "(#{@array.map { |e| e.inspect }.join ' '})"
     end
 
     alias to_s inspect

data/lib/opal/version.rb

@@ -1,3 +1,3 @@
 module Opal
-  VERSION = '0.5.2'
+  VERSION = '0.5.4'
 end

data/opal.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |s|
   s.homepage     = 'http://opalrb.org'
   s.summary      = 'Ruby runtime and core library for javascript'
   s.description  = 'Ruby runtime and core library for javascript.'
+  s.license      = 'MIT'
 
   s.files          = `git ls-files`.split("\n")
   s.executables    = ['opal']

data/opal/core/array.rb

@@ -4,6 +4,21 @@ class Array
   # Mark all javascript arrays as being valid ruby arrays
   `def._isArray = true`
 
+  def self.inherited(klass)
+    replace = Class.new(Array::Wrapper)
+
+    %x{
+      klass._proto        = replace._proto;
+      klass._proto._klass = klass;
+      klass._alloc        = replace._alloc;
+      klass.__parent      = #{Array::Wrapper};
+
+      klass.$allocate = replace.$allocate;
+      klass.$new      = replace.$new;
+      klass["$[]"]    = replace["$[]"];
+    }
+  end
+
   def self.[](*objects)
     objects
   end
@@ -70,7 +85,7 @@ class Array
     if Array === other
       other = other.to_a
     else
-      other = Opal.coerce_to other, Array, :to_ary
+      other = Opal.coerce_to(other, Array, :to_ary).to_a
     end
 
     %x{
@@ -124,7 +139,7 @@ class Array
     if Array === other
       other = other.to_a
     else
-      other = Opal.coerce_to other, Array, :to_ary
+      other = Opal.coerce_to(other, Array, :to_ary).to_a
     end
 
     `self.concat(other)`
@@ -134,7 +149,7 @@ class Array
     if Array === other
       other = other.to_a
     else
-      other = Opal.coerce_to other, Array, :to_ary
+      other = Opal.coerce_to(other, Array, :to_ary).to_a
     end
 
     return [] if `self.length === 0`
@@ -170,7 +185,7 @@ class Array
     if Array === other
       other = other.to_a
     elsif other.respond_to? :to_ary
-      other = other.to_ary
+      other = other.to_ary.to_a
     else
       return
     end
@@ -197,15 +212,18 @@ class Array
   end
 
   def ==(other)
-    return false unless Array === other
+    return true if `self === other`
+
+    unless Array === other
+      return false unless other.respond_to? :to_ary
+      return other == self
+    end
 
     other = other.to_a
 
-    %x{
-      if (self.length !== other.length) {
-        return false;
-      }
+    return false unless `self.length === other.length`
 
+    %x{
       for (var i = 0, length = self.length; i < length; i++) {
         var a = self[i],
             b = other[i];
@@ -214,7 +232,7 @@ class Array
           continue;
         }
 
-        if (!(#{`a` == `b`})) {
+        if (!#{`a` == `b`}) {
           return false;
         }
       }
@@ -224,104 +242,187 @@ class Array
   end
 
   def [](index, length = undefined)
-    %x{
-      var size = self.length;
+    if Range === index
+      %x{
+        var size    = self.length,
+            exclude = index.exclude,
+            from    = #{Opal.coerce_to `index.begin`, Integer, :to_int},
+            to      = #{Opal.coerce_to `index.end`, Integer, :to_int};
 
-      if (typeof index !== 'number' && !index._isNumber) {
-        if (index._isRange) {
-          var exclude = index.exclude;
-          length      = index.end;
-          index       = index.begin;
+        if (from < 0) {
+          from += size;
 
-          if (index > size) {
+          if (from < 0) {
             return nil;
           }
+        }
 
-          if (length < 0) {
-            length += size;
-          }
+        #{Opal.fits_fixnum!(`from`)};
 
-          if (!exclude) length += 1;
-          return self.slice(index, length);
+        if (from > size) {
+          return nil;
         }
-        else {
-          #{ raise "bad arg for Array#[]" };
+
+        if (to < 0) {
+          to += size;
+
+          if (to < 0) {
+            return [];
+          }
         }
-      }
 
-      if (index < 0) {
-        index += size;
-      }
+        #{Opal.fits_fixnum!(`to`)};
 
-      if (length !== undefined) {
-        if (length < 0 || index > size || index < 0) {
-          return nil;
+        if (!exclude) {
+          to += 1;
         }
 
-        return self.slice(index, index + length);
+        return self.slice(from, to);
       }
-      else {
-        if (index >= size || index < 0) {
-          return nil;
+    else
+      index = Opal.coerce_to index, Integer, :to_int
+
+      %x{
+        var size = self.length;
+
+        if (index < 0) {
+          index += size;
+
+          if (index < 0) {
+            return nil;
+          }
         }
 
-        return self[index];
+        #{Opal.fits_fixnum!(`index`)};
+
+        if (length === undefined) {
+          if (index >= size || index < 0) {
+            return nil;
+          }
+
+          return self[index];
+        }
+        else {
+          length = #{Opal.coerce_to length, Integer, :to_int};
+
+          #{Opal.fits_fixnum!(`length`)};
+
+          if (length < 0 || index > size || index < 0) {
+            return nil;
+          }
+
+          return self.slice(index, index + length);
+        }
       }
-    }
+    end
   end
 
   def []=(index, value, extra = undefined)
-    %x{
-      var size = self.length;
+    if Range === index
+      if Array === value
+        data = value.to_a
+      elsif value.respond_to? :to_ary
+        data = value.to_ary.to_a
+      else
+        data = [value]
+      end
 
-      if (typeof index !== 'number' && !index._isNumber) {
-        if (index._isRange) {
-          var exclude = index.exclude;
-          extra = value;
-          value = index.end;
-          index = index.begin;
+      %x{
+        var size    = self.length,
+            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;
 
-          if (value < 0) {
-            value += size;
+          if (from < 0) {
+            #{raise RangeError, "#{index.inspect} out of range"};
           }
+        }
+
+        #{Opal.fits_fixnum!(`from`)};
+
+        if (to < 0) {
+          to += size;
+        }
 
-          if (!exclude) value += 1;
+        #{Opal.fits_fixnum!(`to`)};
 
-          value = value - index;
+        if (!exclude) {
+          to += 1;
+        }
+
+        if (from > size) {
+          for (var i = size; i < index; i++) {
+            self[i] = nil;
+          }
+        }
+
+        if (to < 0) {
+          self.splice.apply(self, [from, 0].concat(data));
         }
         else {
-          #{raise ArgumentError};
+          self.splice.apply(self, [from, to - from].concat(data));
         }
-      }
 
-      if (index < 0) {
-        index += size;
+        return value;
       }
+    else
+      if `extra === undefined`
+        length = 1
+      else
+        length = value
+        value  = extra
+
+        if Array === value
+          data = value.to_a
+        elsif value.respond_to? :to_ary
+          data = value.to_ary.to_a
+        else
+          data = [value]
+        end
+      end
+
+      %x{
+        var size   = self.length,
+            index  = #{Opal.coerce_to index, Integer, :to_int},
+            length = #{Opal.coerce_to length, Integer, :to_int},
+            old;
+
+        if (index < 0) {
+          old    = index;
+          index += size;
+
+          if (index < 0) {
+            #{raise IndexError, "index #{`old`} too small for array; minimum #{`-self.length`}"};
+          }
+        }
 
-      if (extra != null) {
-        if (value < 0) {
-          #{raise IndexError};
+        #{Opal.fits_fixnum!(`index`)};
+
+        if (length < 0) {
+          #{raise IndexError, "negative length (#{length})"}
         }
 
+        #{Opal.fits_fixnum!(`length`)};
+
         if (index > size) {
-          for (var i = size; index > i; i++) {
+          for (var i = size; i < index; i++) {
             self[i] = nil;
           }
         }
 
-        self.splice.apply(self, [index, value].concat(extra));
-
-        return extra;
-      }
-
-      if (index > size) {
-        for (var i = size; i < index; i++) {
-          self[i] = nil;
+        if (extra === undefined) {
+          self[index] = value;
+        }
+        else {
+          self.splice.apply(self, [index, length].concat(data));
         }
-      }
 
-      return self[index] = value;
-    }
+        return value;
+      }
+    end
   end
 
   def assoc(object)
@@ -401,7 +502,19 @@ class Array
   end
 
   def clone
-    `self.slice()`
+    copy = []
+    copy.initialize_clone(self)
+    copy
+  end
+
+  def dup
+    copy = []
+    copy.initialize_dup(self)
+    copy
+  end
+
+  def initialize_copy(other)
+    replace other
   end
 
   def collect(&block)
@@ -477,7 +590,7 @@ class Array
     if Array === other
       other = other.to_a
     else
-      other = Opal.coerce_to other, Array, :to_ary
+      other = Opal.coerce_to(other, Array, :to_ary).to_a
     end
 
     %x{
@@ -593,6 +706,32 @@ class Array
     `self.length === 0`
   end
 
+  def eql?(other)
+    return true if `self === other`
+    return false unless Array === other
+
+    other = other.to_a
+
+    return false unless `self.length === other.length`
+
+    %x{
+      for (var i = 0, length = self.length; i < length; i++) {
+        var a = self[i],
+            b = other[i];
+
+        if (a._isArray && b._isArray && (a === self)) {
+          continue;
+        }
+
+        if (!#{`a`.eql? `b`}) {
+          return false;
+        }
+      }
+    }
+
+    true
+  end
+
   def fetch(index, defaults = undefined, &block)
     %x{
       var original = index;
@@ -670,11 +809,8 @@ class Array
       right = @length
     end
 
-    if `right > 2147483648`
-      raise RangeError, "bignum too big to convert into `long'"
-    elsif `right >= 536870910`
-      raise ArgumentError, "argument too big"
-    end
+    Opal.fits_fixnum!(right)
+    Opal.fits_array!(right)
 
     if `left > #@length`
       %x{
@@ -1009,6 +1145,12 @@ class Array
   end
 
   def replace(other)
+    if Array === other
+      other = other.to_a
+    else
+      other = Opal.coerce_to(other, Array, :to_ary).to_a
+    end
+
     %x{
       self.splice(0, self.length);
       self.push.apply(self, other);
@@ -1260,7 +1402,7 @@ class Array
       if Array === row
         row = row.to_a
       else
-        row = Opal.coerce_to row, Array, :to_ary
+        row = Opal.coerce_to(row, Array, :to_ary).to_a
       end
 
       max ||= `row.length`
@@ -1282,18 +1424,18 @@ class Array
     %x{
       var result = [],
           seen   = {};
-   
+
       for (var i = 0, length = self.length, item, hash; i < length; i++) {
         item = self[i];
         hash = item;
-   
+
         if (!seen[hash]) {
           seen[hash] = true;
-   
+
           result.push(item);
         }
       }
-   
+
       return result;
     }
   end
@@ -1364,3 +1506,100 @@ class Array
     }
   end
 end
+
+class Array::Wrapper
+  def self.allocate(array = [])
+    obj = super()
+    `obj.literal = array`
+    obj
+  end
+
+  def self.new(*args, &block)
+    obj = allocate
+    obj.initialize(*args, &block)
+    obj
+  end
+
+  def self.[](*objects)
+    allocate(objects)
+  end
+
+  def initialize(*args, &block)
+    @literal = Array.new(*args, &block)
+  end
+
+  def method_missing(*args, &block)
+    result = @literal.__send__(*args, &block)
+
+    if `result === #@literal`
+      self
+    else
+      result
+    end
+  end
+
+  def initialize_copy(other)
+    @literal = `other.literal`.clone
+  end
+
+  def respond_to?(name, *)
+    super || @literal.respond_to?(name)
+  end
+
+  def ==(other)
+    @literal == other
+  end
+
+  def eql?(other)
+    @literal.eql?(other)
+  end
+
+  def to_a
+    @literal
+  end
+
+  def to_ary
+    self
+  end
+
+  def inspect
+    @literal.inspect
+  end
+
+  # wrapped results
+  def *(other)
+    %x{
+      var result = #{@literal * other};
+
+      if (result._isArray) {
+        return #{self.class.allocate(`result`)}
+      }
+      else {
+        return result;
+      }
+    }
+  end
+
+  def [](index, length = undefined)
+    %x{
+      var result = #{@literal.slice(index, length)};
+
+      if (result._isArray && (index._isRange || length !== undefined)) {
+        return #{self.class.allocate(`result`)}
+      }
+      else {
+        return result;
+      }
+    }
+  end
+
+  alias slice []
+
+  def uniq
+    self.class.allocate(@literal.uniq)
+  end
+
+  def flatten(level = undefined)
+    self.class.allocate(@literal.flatten(level))
+  end
+end