opal 0.5.5 → 0.6.0

data/opal/corelib/array/inheritance.rb

@@ -0,0 +1,113 @@
+class Array
+  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
+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

data/opal/corelib/basic_object.rb

@@ -30,6 +30,10 @@ class BasicObject
     }
   end
 
+  def !
+    false
+  end
+
   alias eql? ==
   alias equal? ==
 
@@ -37,12 +41,12 @@ class BasicObject
     Kernel.raise ArgumentError, "no block given" unless block
 
     %x{
-      var block_self = block._s,
+      var old = block._s,
           result;
 
       block._s = null;
       result = block.call(self, self);
-      block._s = block_self;
+      block._s = old;
 
       return result;
     }

data/opal/corelib/boolean.rb

@@ -5,6 +5,10 @@ class Boolean
     undef_method :new
   end
 
+  def !
+    `self != true`
+  end
+
   def &(other)
     `(self == true) ? (other !== false && other !== nil) : false`
   end

data/opal/corelib/class.rb

@@ -1,3 +1,5 @@
+require 'corelib/module'
+
 class Class
   def self.new(sup = Object, &block)
     %x{

data/opal/corelib/complex.rb

@@ -0,0 +1,3 @@
+class Complex < Numeric
+
+end

data/opal/corelib/enumerable.rb

@@ -95,7 +95,8 @@ module Enumerable
   end
 
   def collect_concat(&block)
-    raise NotImplementedError
+    return enum_for :collect_concat unless block_given?
+    map { |item| yield item }.flatten(1)
   end
 
   def count(object = undefined, &block)
@@ -317,7 +318,7 @@ module Enumerable
         slice.push(param);
 
         if (slice.length === n) {
-          if (block(slice) === $breaker) {
+          if ($opal.$yield1(block, slice) === $breaker) {
             result = $breaker.$v;
             return $breaker;
           }
@@ -334,7 +335,7 @@ module Enumerable
 
       // our "last" group, if smaller than n then won't have been yielded
       if (slice.length > 0) {
-        if (block(slice) === $breaker) {
+        if ($opal.$yield1(block, slice) === $breaker) {
           return $breaker.$v;
         }
       }
@@ -939,13 +940,80 @@ module Enumerable
   end
 
   def partition(&block)
-    raise NotImplementedError
+    return enum_for :partition unless block_given?
+
+    %x{
+      var truthy = [], falsy = [];
+
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        if (#{Opal.truthy?(`value`)}) {
+          truthy.push(param);
+        }
+        else {
+          falsy.push(param);
+        }
+      };
+
+      self.$each();
+
+      return [truthy, falsy];
+    }
   end
 
   alias reduce inject
 
+  def reject(&block)
+    return enum_for :reject unless block_given?
+
+    %x{
+      var result = [];
+
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        if (#{Opal.falsy?(`value`)}) {
+          result.push(param);
+        }
+      };
+
+      self.$each();
+
+      return result;
+    }
+  end
+
   def reverse_each(&block)
-    raise NotImplementedError
+    return enum_for :reverse_each unless block_given?
+
+    %x{
+      var result = [];
+
+      self.$each._p = function() {
+        result.push(arguments);
+      };
+
+      self.$each();
+
+      for (var i = result.length - 1; i >= 0; i--) {
+        $opal.$yieldX(block, result[i]);
+      }
+
+      return result;
+    }
   end
 
   alias select find_all
@@ -1058,8 +1126,7 @@ module Enumerable
 
   alias to_a entries
 
-  def zip(*lists, &block)
-    raise NotImplementedError
+  def zip(*others, &block)
+    to_a.zip(*others)
   end
 end
-

data/opal/corelib/enumerator.rb

@@ -1,3 +1,5 @@
+require 'corelib/enumerable'
+
 class Enumerator
   include Enumerable
 

data/opal/corelib/error.rb

@@ -15,7 +15,7 @@ class Exception
       var backtrace = self.stack;
 
       if (typeof(backtrace) === 'string') {
-        return backtrace.split("\\n").slice(0, 15);
+        return backtrace.split("\n").slice(0, 15);
       }
       else if (backtrace) {
         return backtrace.slice(0, 15);
@@ -33,29 +33,29 @@ class Exception
 end
 
 # keep the indentation, it makes the exception hierarchy clear
-class StandardError < Exception; end
-  class SystemCallError < StandardError; end
-  class NameError < StandardError; end
-    class NoMethodError < NameError; end
-  class RuntimeError < StandardError; end
-  class LocalJumpError < StandardError; end
-  class TypeError < StandardError; end
-  class ArgumentError < StandardError; end
-  class IndexError < StandardError; end
-    class StopIteration < IndexError; end
-    class KeyError < IndexError; end
-  class RangeError < StandardError; end
-    class FloatDomainError < RangeError; end
-  class IOError < StandardError; end
-
-class ScriptError < Exception; end
-  class SyntaxError < ScriptError; end
-  class NotImplementedError < ScriptError; end
-
-class SystemExit < Exception; end
-
+class ScriptError       < Exception; end
+class SyntaxError         < ScriptError; end
+class LoadError           < ScriptError; end
+class NotImplementedError < ScriptError; end
+
+class SystemExit        < Exception; end
+
+class StandardError     < Exception; end
+class NameError           < StandardError; end
+class NoMethodError         < NameError; end
+class RuntimeError        < StandardError; end
+class LocalJumpError      < StandardError; end
+class TypeError           < StandardError; end
+class ArgumentError       < StandardError; end
+class IndexError          < StandardError; end
+class StopIteration         < IndexError; end
+class KeyError              < IndexError; end
+class RangeError          < StandardError; end
+class FloatDomainError      < RangeError; end
+class IOError             < StandardError; end
+class SystemCallError     < StandardError; end
 module Errno
-  class EINVAL < SystemCallError
+  class EINVAL              < SystemCallError
     def self.new
       super('Invalid argument')
     end

data/opal/corelib/hash.rb

@@ -1,8 +1,8 @@
+require 'corelib/enumerable'
+
 class Hash
   include Enumerable
 
-  `var $hasOwn = {}.hasOwnProperty`
-
   def self.[](*objs)
     `$opal.hash.apply(null, objs)`
   end
@@ -64,7 +64,7 @@ class Hash
     %x{
       var map = self.map;
 
-      if ($hasOwn.call(map, key)) {
+      if ($opal.hasOwnProperty.call(map, key)) {
         return map[key];
       }
 
@@ -82,7 +82,7 @@ class Hash
     %x{
       var map = self.map;
 
-      if (!$hasOwn.call(map, key)) {
+      if (!$opal.hasOwnProperty.call(map, key)) {
         self.keys.push(key);
       }
 
@@ -314,7 +314,7 @@ class Hash
   end
 
   def has_key?(key)
-    `$hasOwn.call(self.map, key)`
+    `$opal.hasOwnProperty.call(self.map, key)`
   end
 
   def has_value?(value)

data/opal/corelib/helpers.rb

@@ -1,9 +1,17 @@
 module Opal
+  def self.type_error(object, type, method = nil, coerced = nil)
+    if method && coerced
+      TypeError.new "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
+    else
+      TypeError.new "no implicit conversion of #{object.class} into #{type}"
+    end
+  end
+
   def self.coerce_to(object, type, method)
     return object if type === object
 
     unless object.respond_to? method
-      raise TypeError, "no implicit conversion of #{object.class} into #{type}"
+      raise type_error(object, type)
     end
 
     object.__send__ method
@@ -13,7 +21,21 @@ module Opal
     coerced = coerce_to(object, type, method)
 
     unless type === coerced
-      raise TypeError, "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
+      raise type_error(object, type, method, coerced)
+    end
+
+    coerced
+  end
+
+  def self.coerce_to?(object, type, method)
+    return unless object.respond_to? method
+
+    coerced = coerce_to(object, type, method)
+
+    return if coerced.nil?
+
+    unless type === coerced
+      raise type_error(object, type, method, coerced)
     end
 
     coerced
@@ -37,20 +59,6 @@ module Opal
     compare
   end
 
-  def self.fits_fixnum!(value)
-    # since we have Fixnum#size as 32 bit, this is based on the int limits
-    if `value > 2147483648`
-      raise RangeError, "bignum too big to convert into `long'"
-    end
-  end
-
-  def self.fits_array!(value)
-    # this is the computed ARY_MAX_SIZE for 32 bit
-    if `value >= 536870910`
-      raise ArgumentError, "argument too big"
-    end
-  end
-
   def self.destructure(args)
     %x{
       if (args.length == 1) {
@@ -64,4 +72,31 @@ module Opal
       }
     }
   end
+
+  def self.respond_to?(obj, method)
+    %x{
+      if (obj == null || !obj._klass) {
+        return false;
+      }
+    }
+
+    obj.respond_to? method
+  end
+
+  def self.inspect(obj)
+    %x{
+      if (obj === undefined) {
+        return "undefined";
+      }
+      else if (obj === null) {
+        return "null";
+      }
+      else if (!obj._klass) {
+        return obj.toString();
+      }
+      else {
+        return #{obj.inspect};
+      }
+    }
+  end
 end