opal 0.5.2 → 0.5.4

data/opal/core/enumerable.rb

@@ -67,6 +67,10 @@ module Enumerable
     }
   end
 
+  def chunk(state = undefined, &block)
+    raise NotImplementedError
+  end
+
   def collect(&block)
     return enum_for :collect unless block_given?
 
@@ -90,6 +94,10 @@ module Enumerable
     }
   end
 
+  def collect_concat(&block)
+    raise NotImplementedError
+  end
+
   def count(object = undefined, &block)
     %x{
       var result = 0;
@@ -282,6 +290,14 @@ module Enumerable
     }
   end
 
+  def each_cons(n, &block)
+    raise NotImplementedError
+  end
+
+  def each_entry(&block)
+    raise NotImplementedError
+  end
+
   def each_slice(n, &block)
     n = Opal.coerce_to n, Integer, :to_int
 
@@ -511,6 +527,8 @@ module Enumerable
     result
   end
 
+  alias flat_map collect_concat
+
   def grep(pattern, &block)
     %x{
       var result = [];
@@ -658,7 +676,6 @@ module Enumerable
   def enumerator_size
     respond_to?(:size) ? size : nil
   end
-
   private :enumerator_size
 
   alias map collect
@@ -833,6 +850,14 @@ module Enumerable
     }
   end
 
+  def minmax(&block)
+    raise NotImplementedError
+  end
+
+  def minmax_by(&block)
+    raise NotImplementedError
+  end
+
   def none?(&block)
     %x{
       var result = true;
@@ -913,6 +938,18 @@ module Enumerable
     }
   end
 
+  def partition(&block)
+    raise NotImplementedError
+  end
+
+  alias reduce inject
+
+  def reverse_each(&block)
+    raise NotImplementedError
+  end
+
+  alias select find_all
+
   def slice_before(pattern = undefined, &block)
     if `pattern === undefined && block === nil || arguments.length > 1`
       raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 1)"
@@ -973,6 +1010,10 @@ module Enumerable
     }
   end
 
+  def sort(&block)
+    raise NotImplementedError
+  end
+
   def sort_by(&block)
     return enum_for :sort_by unless block_given?
 
@@ -983,10 +1024,6 @@ module Enumerable
     }.sort { |a, b| a[0] <=> b[0] }.map { |arg| `arg[1]` }
   end
 
-  alias select find_all
-
-  alias reduce inject
-
   def take(num)
     first(num)
   end
@@ -1020,5 +1057,9 @@ module Enumerable
   end
 
   alias to_a entries
+
+  def zip(*lists, &block)
+    raise NotImplementedError
+  end
 end
 

data/opal/core/hash.rb

@@ -1,68 +1,10 @@
 class Hash
   include Enumerable
 
-  %x{
-    var $hash = Opal.hash = function() {
-      if (arguments.length == 1 && arguments[0]._klass == Hash) {
-        return arguments[0];
-      }
-
-      var hash   = new Hash._alloc,
-          keys   = [],
-          assocs = {};
-
-      hash.map   = assocs;
-      hash.keys  = keys;
-
-      if (arguments.length == 1 && arguments[0]._isArray) {
-        var args = arguments[0];
-
-        for (var i = 0, length = args.length; i < length; i++) {
-          var key = args[i][0], obj = args[i][1];
-
-          if (assocs[key] == null) {
-            keys.push(key);
-          }
-
-          assocs[key] = obj;
-        }
-      }
-      else {
-        for (var i = 0, length = arguments.length; i < length; i++) {
-          var key = arguments[i],
-              obj = arguments[++i];
-
-          if (assocs[key] == null) {
-            keys.push(key);
-          }
-
-          assocs[key] = obj;
-        }
-      }
-
-      return hash;
-    };
-  }
-
-  # hash2 is a faster creator for hashes that just use symbols and
-  # strings as keys. The map and keys array can be constructed at
-  # compile time, so they are just added here by the constructor
-  # function
-  %x{
-    var $hash2 = Opal.hash2 = function(keys, map) {
-      var hash = new Hash._alloc;
-
-      hash.keys = keys;
-      hash.map  = map;
-
-      return hash;
-    };
-  }
-
   `var $hasOwn = {}.hasOwnProperty`
 
   def self.[](*objs)
-    `$hash.apply(null, objs)`
+    `$opal.hash.apply(null, objs)`
   end
 
   def self.allocate
@@ -450,7 +392,7 @@ class Hash
 
   def invert
     %x{
-      var result = $hash(), keys = self.keys, map = self.map,
+      var result = $opal.hash(), keys = self.keys, map = self.map,
           keys2 = result.keys, map2 = result.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
@@ -507,7 +449,7 @@ class Hash
   def merge(other, &block)
     %x{
       var keys = self.keys, map = self.map,
-          result = $hash(), keys2 = result.keys, map2 = result.map;
+          result = $opal.hash(), keys2 = result.keys, map2 = result.map;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i];
@@ -602,7 +544,7 @@ class Hash
 
     %x{
       var keys = self.keys, map = self.map,
-          result = $hash(), map2 = result.map, keys2 = result.keys;
+          result = $opal.hash(), map2 = result.map, keys2 = result.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key], value;
@@ -640,7 +582,7 @@ class Hash
 
     %x{
       var keys = self.keys, map = self.map,
-          result = $hash(), map2 = result.map, keys2 = result.keys;
+          result = $opal.hash(), map2 = result.map, keys2 = result.keys;
 
       for (var i = 0, length = keys.length; i < length; i++) {
         var key = keys[i], obj = map[key], value;
@@ -722,7 +664,7 @@ class Hash
 
   def to_h
     %x{
-      var hash   = new Hash._alloc,
+      var hash   = new Opal.Hash._alloc,
           cloned = #{clone};
 
       hash.map  = cloned.map;

data/opal/core/helpers.rb

@@ -0,0 +1,67 @@
+module Opal
+  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}"
+    end
+
+    object.__send__ method
+  end
+
+  def self.coerce_to!(object, type, method)
+    coerced = coerce_to(object, type, method)
+
+    unless type === coerced
+      raise TypeError, "can't convert #{object.class} into #{type} (#{object.class}##{method} gives #{coerced.class}"
+    end
+
+    coerced
+  end
+
+  def self.try_convert(object, type, method)
+    return object if type === object
+
+    if object.respond_to? method
+      object.__send__ method
+    end
+  end
+
+  def self.compare(a, b)
+    compare = a <=> b
+
+    if `compare === nil`
+      raise ArgumentError, "comparison of #{a.class.name} with #{b.class.name} failed"
+    end
+
+    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) {
+        return args[0];
+      }
+      else if (args._isArray) {
+        return args;
+      }
+      else {
+        return $slice.call(args);
+      }
+    }
+  end
+end

data/opal/core/method.rb

@@ -16,7 +16,7 @@ class Method
     %x{
       #@method._p = block;
 
-      return #@method.apply(#@object, args);
+      return #@method.apply(#@receiver, args);
     }
   end
 

data/opal/core/module.rb

@@ -2,15 +2,15 @@ class Module
   def self.new(&block)
     %x{
       function AnonModule(){}
-      var klass     = Opal.boot(Module, AnonModule);
+      var klass     = Opal.boot(Opal.Module, AnonModule);
       klass._name   = nil;
-      klass._klass  = Module;
+      klass._klass  = Opal.Module;
       klass.__dep__ = []
       klass.__mod__ = true;
       klass._proto  = {};
 
       // inherit scope from parent
-      $opal.create_scope(Module._scope, klass);
+      $opal.create_scope(Opal.Module._scope, klass);
 
       if (block !== nil) {
         var block_self = block._s;
@@ -262,7 +262,7 @@ class Module
   def define_method(name, method = undefined, &block)
     %x{
       if (method) {
-        block = method;
+        block = #{method.to_proc};
       }
 
       if (block === nil) {

data/opal/core/range.rb

@@ -1,18 +1,7 @@
 class Range
   include Enumerable
 
-  %x{
-    Range._proto._isRange = true;
-
-    Opal.range = function(first, last, exc) {
-      var range         = new Range._alloc;
-          range.begin   = first;
-          range.end     = last;
-          range.exclude = exc;
-
-      return range;
-    };
-  }
+  `def._isRange = true;`
 
   attr_reader :begin, :end
 

data/opal/core/regexp.rb

@@ -2,7 +2,7 @@ class Regexp
   `def._isRegexp = true`
 
   def self.escape(string)
-    `string.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\^\\$\\|]/g, '\\\\$&')`
+    `string.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\^\\$\\| ]/g, '\\\\$&')`
   end
 
   def self.union(*parts)
@@ -36,13 +36,7 @@ class Regexp
       return
     end
 
-    if `string._isString == null`
-      unless string.respond_to? :to_str
-        raise TypeError, "no implicit conversion of #{string.class} into String"
-      end
-
-      string = string.to_str
-    end
+    string = Opal.coerce_to(string, String, :to_str).to_s
 
     %x{
       var re = self;

data/opal/core/runtime.js

@@ -494,7 +494,7 @@
     }
     else {
       if (obj._isClass) {
-        dispatcher = obj._klass;
+        dispatcher = obj._super;
       }
       else {
         dispatcher = find_obj_super_dispatcher(obj, jsid, current_func);
@@ -603,6 +603,10 @@
   };
 
   Opal.is_a = function(object, klass) {
+    if (object.__meta__ === klass) {
+      return true;
+    }
+
     var search = object._klass;
 
     while (search) {
@@ -735,6 +739,75 @@
     }
   }
 
+  Opal.hash = function() {
+    if (arguments.length == 1 && arguments[0]._klass == Opal.Hash) {
+      return arguments[0];
+    }
+
+    var hash   = new Opal.Hash._alloc,
+        keys   = [],
+        assocs = {};
+
+    hash.map   = assocs;
+    hash.keys  = keys;
+
+    if (arguments.length == 1 && arguments[0]._isArray) {
+      var args = arguments[0];
+
+      for (var i = 0, length = args.length; i < length; i++) {
+        var key = args[i][0], obj = args[i][1];
+
+        if (assocs[key] == null) {
+          keys.push(key);
+        }
+
+        assocs[key] = obj;
+      }
+    }
+    else {
+      for (var i = 0, length = arguments.length; i < length; i++) {
+        var key = arguments[i],
+            obj = arguments[++i];
+
+        if (assocs[key] == null) {
+          keys.push(key);
+        }
+
+        assocs[key] = obj;
+      }
+    }
+
+    return hash;
+  };
+
+  /*
+   * hash2 is a faster creator for hashes that just use symbols and
+   * strings as keys. The map and keys array can be constructed at
+   * compile time, so they are just added here by the constructor
+   * function
+   */
+  Opal.hash2 = function(keys, map) {
+    var hash = new Opal.Hash._alloc;
+
+    hash.keys = keys;
+    hash.map  = map;
+
+    return hash;
+  };
+
+  /*
+   * Create a new range instance with first and last values, and whether the
+   * range excludes the last value.
+   */
+  Opal.range = function(first, last, exc) {
+    var range         = new Opal.Range._alloc;
+        range.begin   = first;
+        range.end     = last;
+        range.exclude = exc;
+
+    return range;
+  };
+
   // Initialization
   // --------------
 
@@ -782,8 +855,6 @@
     return this.$to_s();
   };
 
-  RubyClass._proto._defn = function(mid, body) { this._proto[mid] = body; };
-
   Opal.top = new RubyObject._alloc();
 
   Opal.klass(RubyObject, RubyObject, 'NilClass', NilClass);