opal 0.5.5 → 0.6.0

data/lib/opal/version.rb

@@ -1,3 +1,3 @@
 module Opal
-  VERSION = '0.5.5'
+  VERSION = '0.6.0'
 end

data/opal.gemspec

@@ -19,11 +19,11 @@ Gem::Specification.new do |s|
   s.require_paths  = ['lib']
 
   s.add_dependency 'source_map'
+  s.add_dependency 'sprockets'
 
   s.add_development_dependency 'mspec', '1.5.20'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'racc'
-  s.add_development_dependency 'opal-sprockets', '~> 0.3.0'
   s.add_development_dependency 'rspec', '~> 2.14'
   s.add_development_dependency 'octokit', '~> 2.4.0'
 end

data/opal/corelib/array.rb

@@ -1,24 +1,11 @@
+require 'corelib/enumerable'
+
 class Array
   include Enumerable
 
   # 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
@@ -75,10 +62,7 @@ class Array
   end
 
   def self.try_convert(obj)
-    return obj if Array === obj
-    return obj.to_ary if obj.respond_to? :to_ary
-
-    nil
+    Opal.coerce_to? obj, Array, :to_ary
   end
 
   def &(other)
@@ -257,8 +241,6 @@ class Array
           }
         }
 
-        #{Opal.fits_fixnum!(`from`)};
-
         if (from > size) {
           return nil;
         }
@@ -271,8 +253,6 @@ class Array
           }
         }
 
-        #{Opal.fits_fixnum!(`to`)};
-
         if (!exclude) {
           to += 1;
         }
@@ -293,8 +273,6 @@ class Array
           }
         }
 
-        #{Opal.fits_fixnum!(`index`)};
-
         if (length === undefined) {
           if (index >= size || index < 0) {
             return nil;
@@ -305,8 +283,6 @@ class Array
         else {
           length = #{Opal.coerce_to length, Integer, :to_int};
 
-          #{Opal.fits_fixnum!(`length`)};
-
           if (length < 0 || index > size || index < 0) {
             return nil;
           }
@@ -341,20 +317,16 @@ class Array
           }
         }
 
-        #{Opal.fits_fixnum!(`from`)};
-
         if (to < 0) {
           to += size;
         }
 
-        #{Opal.fits_fixnum!(`to`)};
-
         if (!exclude) {
           to += 1;
         }
 
         if (from > size) {
-          for (var i = size; i < index; i++) {
+          for (var i = size; i < from; i++) {
             self[i] = nil;
           }
         }
@@ -399,14 +371,10 @@ class Array
           }
         }
 
-        #{Opal.fits_fixnum!(`index`)};
-
         if (length < 0) {
           #{raise IndexError, "negative length (#{length})"}
         }
 
-        #{Opal.fits_fixnum!(`length`)};
-
         if (index > size) {
           for (var i = size; i < index; i++) {
             self[i] = nil;
@@ -621,6 +589,8 @@ class Array
 
   def delete_at(index)
     %x{
+      index = #{Opal.coerce_to `index`, Integer, :to_int};
+
       if (index < 0) {
         index += self.length;
       }
@@ -736,6 +706,8 @@ class Array
     %x{
       var original = index;
 
+      index = #{Opal.coerce_to `index`, Integer, :to_int};
+
       if (index < 0) {
         index += self.length;
       }
@@ -809,9 +781,6 @@ class Array
       right = @length
     end
 
-    Opal.fits_fixnum!(right)
-    Opal.fits_array!(right)
-
     if `left > #@length`
       %x{
         for (var i = #@length; i < right; i++) {
@@ -849,16 +818,17 @@ class Array
 
   def first(count = undefined)
     %x{
-      if (count != null) {
+      if (count == null) {
+        return self.length === 0 ? nil : self[0];
+      }
 
-        if (count < 0) {
-          #{raise ArgumentError};
-        }
+      count = #{Opal.coerce_to `count`, Integer, :to_int};
 
-        return self.slice(0, count);
+      if (count < 0) {
+        #{raise ArgumentError, 'negative array size'};
       }
 
-      return self.length === 0 ? nil : self[0];
+      return self.slice(0, count);
     }
   end
 
@@ -869,7 +839,7 @@ class Array
       for (var i = 0, length = self.length; i < length; i++) {
         var item = self[i];
 
-        if (#{`item`.respond_to? :to_ary}) {
+        if (#{Opal.respond_to? `item`, :to_ary}) {
           item = #{`item`.to_ary};
 
           if (level == null) {
@@ -959,6 +929,8 @@ class Array
 
   def insert(index, *objects)
     %x{
+      index = #{Opal.coerce_to `index`, Integer, :to_int};
+
       if (objects.length > 0) {
         if (index < 0) {
           index += self.length + 1;
@@ -1000,15 +972,58 @@ class Array
     }
   end
 
-  def join(sep = '')
+  def join(sep = nil)
+    return "" if `self.length === 0`
+
+    if `sep === nil`
+      sep = $,
+    end
+
     %x{
       var result = [];
 
       for (var i = 0, length = self.length; i < length; i++) {
-        result.push(#{`self[i]`.to_s});
+        var item = self[i];
+
+        if (#{Opal.respond_to? `item`, :to_str}) {
+          var tmp = #{`item`.to_str};
+
+          if (tmp !== nil) {
+            result.push(#{`tmp`.to_s});
+
+            continue;
+          }
+        }
+
+        if (#{Opal.respond_to? `item`, :to_ary}) {
+          var tmp = #{`item`.to_ary};
+
+          if (tmp !== nil) {
+            result.push(#{`tmp`.join(sep)});
+
+            continue;
+          }
+        }
+
+        if (#{Opal.respond_to? `item`, :to_s}) {
+          var tmp = #{`item`.to_s};
+
+          if (tmp !== nil) {
+            result.push(tmp);
+
+            continue;
+          }
+        }
+
+        #{raise NoMethodError, "#{Opal.inspect(`item`)} doesn't respond to #to_str, #to_ary or #to_s"};
       }
 
-      return result.join(sep);
+      if (sep === nil) {
+        return result.join('');
+      }
+      else {
+        return result.join(#{Opal.coerce_to!(sep, String, :to_str).to_s});
+      }
     }
   end
 
@@ -1035,33 +1050,21 @@ class Array
 
   def last(count = undefined)
     %x{
-      var length = self.length;
-
-      if (count === nil || typeof(count) == 'string') {
-        #{ raise TypeError, "no implicit conversion to integer" };
+      if (count == null) {
+        return self.length === 0 ? nil : self[self.length - 1];
       }
 
-      if (typeof(count) == 'object') {
-        if (#{count.respond_to? :to_int}) {
-          count = count['$to_int']();
-        }
-        else {
-          #{ raise TypeError, "no implicit conversion to integer" };
-        }
-      }
+      count = #{Opal.coerce_to `count`, Integer, :to_int};
 
-      if (count == null) {
-        return length === 0 ? nil : self[length - 1];
-      }
-      else if (count < 0) {
-        #{ raise ArgumentError, "negative count given" };
+      if (count < 0) {
+        #{raise ArgumentError, 'negative array size'};
       }
 
-      if (count > length) {
-        count = length;
+      if (count > self.length) {
+        count = self.length;
       }
 
-      return self.slice(length - count, length);
+      return self.slice(self.length - count, self.length);
     }
   end
 
@@ -1074,19 +1077,24 @@ class Array
   alias map! collect!
 
   def pop(count = undefined)
-    %x{
-      var length = self.length;
+    if `count === undefined`
+      return if `self.length === 0`
+      return `self.pop()`
+    end
 
-      if (count == null) {
-        return length === 0 ? nil : self.pop();
-      }
+    count = Opal.coerce_to count, Integer, :to_int
 
-      if (count < 0) {
-        #{ raise ArgumentError, "negative count given" };
-      }
+    if `count < 0`
+      raise ArgumentError, 'negative array size'
+    end
 
-      return count > length ? self.splice(0, self.length) : self.splice(length - count, length);
-    }
+    return [] if `self.length === 0`
+
+    if `count > self.length`
+      `self.splice(0, self.length)`
+    else
+      `self.splice(self.length - count, self.length)`
+    end
   end
 
   def push(*objects)
@@ -1137,11 +1145,12 @@ class Array
   def reject!(&block)
     return enum_for :reject! unless block_given?
 
-    %x{
-      var original = self.length;
-      #{ delete_if &block };
-      return self.length === original ? nil : self;
-    }
+    original = length
+    delete_if(&block)
+
+    unless length == original
+      self
+    end
   end
 
   def replace(other)
@@ -1248,13 +1257,20 @@ class Array
   end
 
   def shift(count = undefined)
-    %x{
-      if (self.length === 0) {
-        return nil;
-      }
+    if `count === undefined`
+      return if `self.length === 0`
+      return `self.shift()`
+    end
 
-      return count == null ? self.shift() : self.splice(0, count)
-    }
+    count = Opal.coerce_to count, Integer, :to_int
+
+    if `count < 0`
+      raise ArgumentError, 'negative array size'
+    end
+
+    return [] if `self.length === 0`
+
+    `self.splice(0, count)`
   end
 
   alias size length
@@ -1506,100 +1522,3 @@ 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