opal 0.4.4 → 0.5.0

data/corelib/basic_object.rb

@@ -3,20 +3,26 @@ class BasicObject
   end
 
   def ==(other)
-    `#{self} === other`
+    `self === other`
   end
 
   def __send__(symbol, *args, &block)
     %x{
-      var func = #{self}['$' + symbol]
+      var func = self['$' + symbol]
 
       if (func) {
-        if (block !== nil) { func._p = block; }
-        return func.apply(#{self}, args);
+        if (block !== nil) {
+          func._p = block;
+        }
+
+        return func.apply(self, args);
+      }
+
+      if (block !== nil) {
+        self.$method_missing._p = block;
       }
 
-      if (block !== nil) { #{self}.$method_missing._p = block; }
-      return #{self}.$method_missing.apply(#{self}, [symbol].concat(args));
+      return self.$method_missing.apply(self, [symbol].concat(args));
     }
   end
 
@@ -24,15 +30,14 @@ class BasicObject
   alias equal? ==
 
   def instance_eval(&block)
-    %x{
-      if (block === nil) {
-        throw new Error("no block given");
-      }
+    Kernel.raise ArgumentError, "no block given" unless block
 
-      var block_self = block._s, result;
+    %x{
+      var block_self = block._s,
+          result;
 
       block._s = null;
-      result = block.call(#{self}, #{self});
+      result = block.call(self, self);
       block._s = block_self;
 
       return result;
@@ -40,15 +45,14 @@ class BasicObject
   end
 
   def instance_exec(*args, &block)
-    %x{
-      if (block === nil) {
-        throw new Error("no block given");
-      }
+    Kernel.raise ArgumentError, "no block given" unless block
 
-      var block_self = block._s, result;
+    %x{
+      var block_self = block._s,
+          result;
 
       block._s = null;
-      result = block.apply(#{self}, args);
+      result = block.apply(self, args);
       block._s = block_self;
 
       return result;

data/corelib/boolean.rb

@@ -1,32 +1,41 @@
 class Boolean
   `def._isBoolean = true`
 
+  class << self
+    undef_method :new
+  end
+
   def &(other)
-    `(#{self} == true) ? (other !== false && other !== nil) : false`
+    `(self == true) ? (other !== false && other !== nil) : false`
   end
 
   def |(other)
-    `(#{self} == true) ? true : (other !== false && other !== nil)`
+    `(self == true) ? true : (other !== false && other !== nil)`
   end
 
   def ^(other)
-    `(#{self} == true) ? (other === false || other === nil) : (other !== false && other !== nil)`
+    `(self == true) ? (other === false || other === nil) : (other !== false && other !== nil)`
   end
 
   def ==(other)
-    `(#{self} == true) === other.valueOf()`
+    `(self == true) === other.valueOf()`
   end
 
+  alias equal? ==
+
   alias singleton_class class
 
   def to_s
-    `(#{self} == true) ? 'true' : 'false'`
+    `(self == true) ? 'true' : 'false'`
   end
 
   def to_n
-    `#{self}.valueOf()`
+    `self.valueOf()`
   end
 end
 
 TrueClass = Boolean
 FalseClass = Boolean
+
+TRUE = true
+FALSE = false

data/corelib/class.rb

@@ -1,10 +1,17 @@
 class Class
   def self.new(sup = Object, &block)
     %x{
+      if (!sup._isClass || sup.__mod__) {
+        #{raise TypeError, "superclass must be a Class"};
+      }
+
       function AnonClass(){};
-      var klass   = Opal.boot(sup, AnonClass)
-      klass._name = nil;
-      klass._scope = sup._scope;
+      var klass       = Opal.boot(sup, AnonClass)
+      klass._name     = nil;
+      klass.__parent  = sup;
+
+      // inherit scope from parent
+      $opal.create_scope(sup._scope, klass);
 
       sup.$inherited(klass);
 
@@ -21,7 +28,7 @@ class Class
 
   def allocate
     %x{
-      var obj = new #{self}._alloc;
+      var obj = new self._alloc;
       obj._id = Opal.uid();
       return obj;
     }
@@ -33,7 +40,6 @@ class Class
   def new(*args, &block)
     %x{
       var obj = #{allocate};
-      obj._id = Opal.uid();
 
       obj.$initialize._p = block;
       obj.$initialize.apply(obj, args);
@@ -42,6 +48,6 @@ class Class
   end
 
   def superclass
-    `#{self}._super || nil`
+    `self._super || nil`
   end
 end

data/corelib/comparable.rb

@@ -1,25 +1,56 @@
 module Comparable
-  def <(other)
-    (self <=> other) == -1
-  end
+  def self.normalize(what)
+    return what if Integer === what
 
-  def <=(other)
-    (self <=> other) <= 0
+    return  1 if what > 0
+    return -1 if what < 0
+    return  0
   end
 
   def ==(other)
-    (self <=> other) == 0
+    return true if equal?(other)
+
+    return false unless cmp = (self <=> other)
+    return Comparable.normalize(cmp) == 0
+  rescue StandardError
+    false
   end
 
   def >(other)
-    (self <=> other) == 1
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+
+    Comparable.normalize(cmp) > 0
   end
 
   def >=(other)
-    (self <=> other) >= 0
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+
+    Comparable.normalize(cmp) >= 0
+  end
+
+  def <(other)
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+
+    Comparable.normalize(cmp) < 0
+  end
+
+  def <=(other)
+    unless cmp = (self <=> other)
+      raise ArgumentError, "comparison of #{self.class} with #{other.class} failed"
+    end
+
+    Comparable.normalize(cmp) <= 0
   end
 
   def between?(min, max)
-    self > min && self < max
+    return false if self < min
+    return false if self > max
+    return true
   end
 end

data/corelib/encoding.rb

@@ -0,0 +1,164 @@
+class Encoding
+  def self.register(name, options = {}, &block)
+    names    = [name] + (options[:aliases] || [])
+    encoding = Class.new(self, &block).
+      new(name, names, options[:ascii] || false, options[:dummy] || false)
+
+    names.each {|name|
+      const_set name.sub('-', '_'), encoding
+    }
+  end
+
+  def self.find(name)
+    return name if self === name
+
+    constants.each {|const|
+      encoding = const_get(const)
+
+      if encoding.name == name || encoding.names.include?(name)
+        return encoding
+      end
+    }
+
+    raise ArgumentError, "unknown encoding name - #{name}"
+  end
+
+  class << self
+    attr_accessor :default_external
+  end
+
+  attr_reader :name, :names
+
+  def initialize(name, names, ascii, dummy)
+    @name  = name
+    @names = names
+    @ascii = ascii
+    @dummy = dummy
+  end
+
+  def ascii_compatible?
+    @ascii
+  end
+
+  def dummy?
+    @dummy
+  end
+
+  def to_s
+    @name
+  end
+
+  def inspect
+    "#<Encoding:#{@name}#{" (dummy)" if @dummy}>"
+  end
+
+  # methods to implement per encoding
+  def each_byte(*)
+    raise NotImplementedError
+  end
+
+  def getbyte(*)
+    raise NotImplementedError
+  end
+
+  def bytesize(*)
+    raise NotImplementedError
+  end
+end
+
+Encoding.register "UTF-8", aliases: ["CP65001"], ascii: true do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+
+        if (code <= 0x7f) {
+          #{yield `code`};
+        }
+        else {
+          var encoded = encodeURIComponent(string.charAt(i)).substr(1).split('%');
+
+          for (var j = 0, encoded_length = encoded.length; j < encoded_length; j++) {
+            #{yield `parseInt(encoded[j], 16)`};
+          }
+        }
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+Encoding.register "UTF-16LE" do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        var code = string.charCodeAt(i);
+
+        #{yield `code & 0xff`};
+        #{yield `code >> 8`};
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+Encoding.register "ASCII-8BIT", aliases: ["BINARY"], ascii: true do
+  def each_byte(string, &block)
+    %x{
+      for (var i = 0, length = string.length; i < length; i++) {
+        #{yield `string.charCodeAt(i) & 0xff`};
+      }
+    }
+  end
+
+  def bytesize
+    bytes.length
+  end
+end
+
+class String
+  `def.encoding = #{Encoding::UTF_16LE}`
+
+  def bytes
+    each_byte.to_a
+  end
+
+  def bytesize
+    @encoding.bytesize(self)
+  end
+
+  def each_byte(&block)
+    return enum_for :each_byte unless block_given?
+
+    @encoding.each_byte(self, &block)
+
+    self
+  end
+
+  def encoding
+    @encoding
+  end
+
+  def force_encoding(encoding)
+    encoding = Encoding.find(encoding)
+
+    return self if encoding == @encoding
+
+    %x{
+      var result = new native_string(self);
+      result.encoding = encoding;
+
+      return result;
+    }
+  end
+
+  def getbyte(idx)
+    @encoding.getbyte(self, idx)
+  end
+end

data/corelib/enumerable.rb

@@ -1,38 +1,33 @@
 module Enumerable
   def all?(&block)
     %x{
-      var result = true, proc;
+      var result = true;
 
       if (block !== nil) {
-        proc = function(obj) {
-          var value;
-          var args = $slice.call(arguments);
+        self.$each._p = function() {
+          var value = $opal.$yieldX(block, arguments);
 
-          if ((value = block.apply(#{self}, args)) === $breaker) {
-            return $breaker.$v;
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
           }
 
-          if (value === false || value === nil) {
+          if (#{Opal.falsy?(`value`)}) {
             result = false;
-            $breaker.$v = nil;
-
             return $breaker;
           }
         }
       }
       else {
-        proc = function(obj) {
-          if ((obj === false || obj === nil) && arguments.length < 2) {
-            result       = false;
-            $breaker.$v = nil;
-
+        self.$each._p = function(obj) {
+          if (arguments.length == 1 && #{Opal.falsy?(`obj`)}) {
+            result = false;
             return $breaker;
           }
         }
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
@@ -40,38 +35,33 @@ module Enumerable
 
   def any?(&block)
     %x{
-      var result = false, proc;
+      var result = false;
 
       if (block !== nil) {
-        proc = function(obj) {
-          var value;
-          var args = $slice.call(arguments);
+        self.$each._p = function() {
+          var value = $opal.$yieldX(block, arguments);
 
-          if ((value = block.apply(#{self}, args)) === $breaker) {
-            return $breaker.$v;
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
           }
 
-          if (value !== false && value !== nil) {
-            result       = true;
-            $breaker.$v = nil;
-
+          if (#{Opal.truthy?(`value`)}) {
+            result = true;
             return $breaker;
           }
-        }
+        };
       }
       else {
-        proc = function(obj) {
-          if ((obj !== false && obj !== nil) || arguments.length >= 2) {
-            result      = true;
-            $breaker.$v = nil;
-
+        self.$each._p = function(obj) {
+          if (arguments.length != 1 || #{Opal.truthy?(`obj`)}) {
+            result = true;
             return $breaker;
           }
         }
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
@@ -83,42 +73,18 @@ module Enumerable
     %x{
       var result = [];
 
-      var proc = function() {
-        var value, args = $slice.call(arguments);
-
-        if ((value = block.apply(null, arguments)) === $breaker) {
-          return $breaker.$v;
-        }
-
-        result.push(value);
-      };
-
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each._p = function() {
+        var value = $opal.$yieldX(block, arguments);
 
-      return result;
-    }
-  end
-
-  def reduce(object = undefined, &block)
-    %x{
-      var result = #{object} == undefined ? 0 : #{object};
-
-      var proc = function() {
-        var obj = $slice.call(arguments), value;
-
-        if ((value = block.apply(nil, [result].concat(obj))) === $breaker) {
+        if (value === $breaker) {
           result = $breaker.$v;
-          $breaker.$v = nil;
-
           return $breaker;
         }
 
-        result = value;
+        result.push(value);
       };
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
@@ -130,196 +96,226 @@ module Enumerable
 
       if (object != null) {
         block = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
-
-          return #{ `param` == `object` };
+          return #{Opal.destructure(`arguments`) == `object`};
         };
       }
       else if (block === nil) {
         block = function() { return true; };
       }
 
-      var proc = function() {
-        var value, param = $slice.call(arguments);
+      self.$each._p = function() {
+        var value = $opal.$yieldX(block, arguments);
 
-        if ((value = block.apply(null, param)) === $breaker) {
-          return $breaker.$v;
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
         }
 
-        if (value !== false && value !== nil) {
+        if (#{Opal.truthy?(`value`)}) {
           result++;
         }
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
   end
 
   def detect(ifnone = undefined, &block)
+    return enum_for :detect, ifnone unless block_given?
+
     %x{
-      var result = nil;
+      var result = undefined;
 
-      #{self}.$each._p = function() {
-        var value;
-        var param = arguments.length == 1 ?
-          arguments[0] : $slice.call(arguments);
+      self.$each._p = function() {
+        var params = #{Opal.destructure(`arguments`)},
+            value  = $opal.$yield1(block, params);
 
-        if ((value = block(param)) === $breaker) {
-          return $breaker.$v;
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
         }
 
-        if (value !== false && value !== nil) {
-          result       = param;
-          $breaker.$v = nil;
-
+        if (#{Opal.truthy?(`value`)}) {
+          result = params;
           return $breaker;
         }
       };
 
-      #{self}.$each();
+      self.$each();
 
-      if (result !== nil) {
-        return result;
-      }
-
-      if (typeof(ifnone) === 'function') {
-        return #{ifnone.call};
+      if (result === undefined && ifnone !== undefined) {
+        if (typeof(ifnone) === 'function') {
+          result = ifnone();
+        }
+        else {
+          result = ifnone;
+        }
       }
 
-      return ifnone == null ? nil : ifnone;
+      return result === undefined ? nil : result;
     }
   end
 
   def drop(number)
+    number = Opal.coerce_to number, Integer, :to_int
+
+    if `number < 0`
+      raise ArgumentError, "attempt to drop negative size"
+    end
+
     %x{
       var result  = [],
           current = 0;
 
-      #{self}.$each._p = function() {
+      self.$each._p = function() {
         if (number < current) {
-          result.push(e);
+          result.push(#{Opal.destructure(`arguments`)});
         }
 
         current++;
       };
 
-      #{self}.$each()
+      self.$each()
 
       return result;
     }
   end
 
   def drop_while(&block)
+    return enum_for :drop_while unless block_given?
+
     %x{
       var result = [];
 
-      #{self}.$each._p = function() {
-        var value;
-        var param = arguments.length == 1 ?
-          arguments[0] : $slice.call(arguments);
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
 
-        if ((value = block(param)) === $breaker) {
+        if (value === $breaker) {
+          result = $breaker.$v;
           return $breaker;
         }
 
-        if (value === false || value === nil) {
-          result.push(param);
-          return value;
+        if (#{Opal.truthy?(`value`)}) {
+          return;
         }
 
-        return $breaker;
+        result.push(param);
       };
 
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
   end
 
   def each_slice(n, &block)
+    n = Opal.coerce_to n, Integer, :to_int
+
+    return enum_for :each_slice, n unless block_given?
+
     %x{
-      var all = [];
+      var result,
+          slice = []
 
-      #{self}.$each._p = function() {
-        var param = arguments.length == 1 ?
-          arguments[0] : $slice.call(arguments);
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)};
 
-        all.push(param);
+        slice.push(param);
+
+        if (slice.length === n) {
+          if (block(slice) === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
 
-        if (all.length == n) {
-          block(all.slice(0));
-          all = [];
+          slice = [];
         }
       };
 
-      #{self}.$each();
+      self.$each();
 
-      // our "last" group, if smaller than n then wont have been yielded
-      if (all.length > 0) {
-        block(all.slice(0));
+      if (result !== undefined) {
+        return result;
       }
 
-      return nil;
+      // our "last" group, if smaller than n then won't have been yielded
+      if (slice.length > 0) {
+        if (block(slice) === $breaker) {
+          return $breaker.$v;
+        }
+      }
     }
+
+    nil
   end
 
   def each_with_index(&block)
+    return enum_for :each_with_index unless block_given?
+
     %x{
-      var index = 0;
+      var result,
+          index = 0;
 
-      #{self}.$each._p = function() {
-        var value;
-        var param = arguments.length == 1 ?
-          arguments[0] : $slice.call(arguments);
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = block(param, index);
 
-        if ((value = block(param, index)) === $breaker) {
-          return $breaker.$v;
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
         }
 
         index++;
       };
-      #{self}.$each();
 
-      return nil;
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
     }
+
+    nil
   end
 
   def each_with_object(object, &block)
+    return enum_for :each_with_object, object unless block_given?
+
     %x{
-      #{self}.$each._p = function() {
-        var value;
-        var param = arguments.length == 1 ?
-          arguments[0] : $slice.call(arguments);
+      var result;
 
-        if ((value = block(param, object)) === $breaker) {
-          return $breaker.$v;
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = block(param, object);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
         }
       };
 
-      #{self}.$each();
+      self.$each();
 
-      return object;
+      if (result !== undefined) {
+        return result;
+      }
     }
+
+    object
   end
 
   def entries
     %x{
       var result = [];
 
-      #{self}.$each._p = function() {
-        if (arguments.length == 1) {
-          result.push(arguments[0]);
-        }
-        else {
-          result.push($slice.call(arguments));
-        }
+      self.$each._p = function() {
+        result.push(#{Opal.destructure(`arguments`)});
       };
 
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
@@ -328,39 +324,43 @@ module Enumerable
   alias find detect
 
   def find_all(&block)
+    return enum_for :find_all unless block_given?
+
     %x{
       var result = [];
 
-      #{self}.$each._p = function() {
-        var value;
-        var param = arguments.length == 1 ?
-          arguments[0] : $slice.call(arguments);
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
 
-        if ((value = block(param)) === $breaker) {
-          return $breaker.$v;
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
         }
 
-        if (value !== false && value !== nil) {
+        if (#{Opal.truthy?(`value`)}) {
           result.push(param);
         }
       };
 
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
   end
 
   def find_index(object = undefined, &block)
+    return enum_for :find_index if `object === undefined && block === nil`
+
     %x{
-      var proc, result = nil, index = 0;
+      var result = nil,
+          index  = 0;
 
       if (object != null) {
-        proc = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)};
 
-          if (#{ `param` == `object` }) {
+          if (#{`param` == `object`}) {
             result = index;
             return $breaker;
           }
@@ -368,20 +368,17 @@ module Enumerable
           index += 1;
         };
       }
-      else {
-        proc = function() {
-          var value;
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+      else if (block !== nil) {
+        self.$each._p = function() {
+          var value = $opal.$yieldX(block, arguments);
 
-          if ((value = block(param)) === $breaker) {
-            return $breaker.$v;
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
           }
 
-          if (value !== false && value !== nil) {
-            result       = index;
-            $breaker.$v = index;
-
+          if (#{Opal.truthy?(`value`)}) {
+            result = index;
             return $breaker;
           }
 
@@ -389,8 +386,7 @@ module Enumerable
         };
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
@@ -398,36 +394,31 @@ module Enumerable
 
   def first(number = undefined)
     %x{
-      var result  = [],
-          current = 0,
-          proc;
-
       if (number == null) {
-        result = nil;
-        proc   = function() {
-          result = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+        var result = nil;
 
+        self.$each._p = function() {
+          result = #{Opal.destructure(`arguments`)};
           return $breaker;
         };
       }
       else {
-        proc = function() {
+        var current = 0,
+            result  = [],
+            number  = #{Opal.coerce_to number, Integer, :to_int};
+
+        self.$each._p = function() {
           if (number <= current) {
             return $breaker;
           }
 
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
-
-          result.push(param);
+          result.push(#{Opal.destructure(`arguments`)});
 
           current++;
         };
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
@@ -435,19 +426,19 @@ module Enumerable
 
   def grep(pattern, &block)
     %x{
-      var result = [],
-          proc;
+      var result = [];
 
       if (block !== nil) {
-        proc = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)},
+              value = #{pattern === `param`};
 
-          var value = #{pattern === `param`};
+          if (#{Opal.truthy?(`value`)}) {
+            value = $opal.$yield1(block, param);
 
-          if (value !== false && value !== nil) {
-            if ((value = block(param)) === $breaker) {
-              return $breaker.$v;
+            if (value === $breaker) {
+              result = $breaker.$v;
+              return $breaker;
             }
 
             result.push(value);
@@ -455,216 +446,457 @@ module Enumerable
         };
       }
       else {
-        proc = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)},
+              value = #{pattern === `param`};
 
-          var value = #{pattern === `param`};
-
-          if (value !== false && value !== nil) {
+          if (#{Opal.truthy?(`value`)}) {
             result.push(param);
           }
         };
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
       return result;
     }
   end
 
   def group_by(&block)
+    return enum_for :group_by unless block_given?
+
     hash = Hash.new { |h, k| h[k] = [] }
 
-    each do |el|
-      hash[block.call(el)] << el
-    end
+    %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;
+        }
+
+        #{hash[`value`] << `param`};
+      }
+
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
+    }
 
     hash
   end
 
-  alias map collect
+  def include?(obj)
+    any? { |v| v == obj }
+  end
 
-  def max(&block)
+  def inject(object = undefined, sym = undefined, &block)
     %x{
-      var proc, result;
-      var arg_error = false;
+      var result = object;
 
       if (block !== nil) {
-        proc = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+        self.$each._p = function() {
+          var value = #{Opal.destructure(`arguments`)};
 
-          if (result == undefined) {
-            result = param;
+          if (result === undefined) {
+            result = value;
+            return;
           }
-          else if ((value = block(param, result)) === $breaker) {
-            result = $breaker.$v;
 
+          value = $opal.$yieldX(block, [result, value]);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
             return $breaker;
           }
-          else {
-            if (value > 0) {
-              result = param;
-            }
 
-            $breaker.$v = nil;
+          result = value;
+        };
+      }
+      else {
+        if (sym === undefined) {
+          if (!#{Symbol === object}) {
+            #{raise TypeError, "#{object.inspect} is not a Symbol"};
           }
+
+          sym    = object;
+          result = undefined;
         }
+
+        self.$each._p = function() {
+          var value = #{Opal.destructure(`arguments`)};
+
+          if (result === undefined) {
+            result = value;
+            return;
+          }
+
+          result = #{`result`.__send__ sym, `value`};
+        };
       }
-      else {
-        proc = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
 
-          var modules = param.$class().$included_modules;
+      self.$each();
 
-          if (modules == undefined || modules.length == 0 || modules.indexOf(Opal.Comparable) == -1) {
-            arg_error = true;
+      return result;
+    }
+  end
+
+  alias map collect
+
+  def max(&block)
+    %x{
+      var result;
+
+      if (block !== nil) {
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)};
+
+          if (result === undefined) {
+            result = param;
+            return;
+          }
 
+          var value = block(param, result);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
             return $breaker;
           }
 
-          if (result == undefined || #{`param` > `result`}) {
+          if (value > 0) {
             result = param;
           }
-        }
+        };
       }
+      else {
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)};
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+          if (result === undefined) {
+            result = param;
+            return;
+          }
 
-      if (arg_error) {
-        #{raise ArgumentError, "Array#max"};
+          if (#{`param` <=> `result`} > 0) {
+            result = param;
+          }
+        };
       }
 
-      return (result == undefined ? nil : result);
+      self.$each();
+
+      return result === undefined ? nil : result;
+    }
+  end
+
+  def max_by(&block)
+    return enum_for :max_by unless block
+
+    %x{
+      var result,
+          by;
+
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
+
+        if (result === undefined) {
+          result = param;
+          by     = value;
+          return;
+        }
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        if (#{`value` <=> `by`} > 0) {
+          result = param
+          by     = value;
+        }
+      };
+
+      self.$each();
+
+      return result === undefined ? nil : result;
     }
   end
 
+  alias member? include?
+
   def min(&block)
     %x{
-      var proc,
-          result,
-          arg_error = false;
+      var result;
 
       if (block !== nil) {
-        proc = function() {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)};
 
-          if (result == undefined) {
+          if (result === undefined) {
             result = param;
+            return;
           }
-          else if ((value = block(param, result)) === $breaker) {
-            result = $breaker.$v;
 
+          var value = block(param, result);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
             return $breaker;
           }
-          else {
-            if (value < 0) {
-              result = param;
-            }
 
-            $breaker.$v = nil;
+          if (value < 0) {
+            result = param;
           }
-        }
+        };
       }
       else {
-        proc = function(obj) {
-          var param = arguments.length == 1 ?
-            arguments[0] : $slice.call(arguments);
-
-          var modules = param.$class().$included_modules;
-
-          if (modules == undefined || modules.length == 0 || modules.indexOf(Opal.Comparable) == -1) {
-            arg_error = true;
+        self.$each._p = function() {
+          var param = #{Opal.destructure(`arguments`)};
 
-            return $breaker;
+          if (result === undefined) {
+            result = param;
+            return;
           }
 
-          if (result == undefined || #{`param` < `result`}) {
+          if (#{`param` <=> `result`} < 0) {
             result = param;
           }
-        }
+        };
       }
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+      self.$each();
 
-      if (arg_error) {
-        #{raise ArgumentError, "Array#min"};
-      }
+      return result === undefined ? nil : result;
+    }
+  end
+
+  def min_by(&block)
+    return enum_for :min_by unless block
+
+    %x{
+      var result,
+          by;
+
+      self.$each._p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
 
-      return result == undefined ? nil : result;
+        if (result === undefined) {
+          result = param;
+          by     = value;
+          return;
+        }
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        if (#{`value` <=> `by`} < 0) {
+          result = param
+          by     = value;
+        }
+      };
+
+      self.$each();
+
+      return result === undefined ? nil : result;
     }
   end
 
   def none?(&block)
     %x{
-      var result = true,
-          proc;
+      var result = true;
 
       if (block !== nil) {
-        proc = function(obj) {
-          var value,
-              args = $slice.call(arguments);
+        self.$each._p = function() {
+          var value = $opal.$yieldX(block, arguments);
 
-          if ((value = block.apply(#{self}, args)) === $breaker) {
-            return $breaker.$v;
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
           }
 
-          if (value !== false && value !== nil) {
-            result       = false;
-            $breaker.$v = nil;
-
+          if (#{Opal.truthy?(`value`)}) {
+            result = false;
             return $breaker;
           }
         }
       }
       else {
-        proc = function(obj) {
-          if (arguments.length == 1 && (obj !== false && obj !== nil)) {
-            result       = false;
-            $breaker.$v = nil;
+        self.$each._p = function() {
+          var value = #{Opal.destructure(`arguments`)};
 
+          if (#{Opal.truthy?(`value`)}) {
+            result = false;
             return $breaker;
           }
-          else {
-            for (var i = 0, length = arguments.length; i < length; i++) {
-              if (arguments[i] !== false && arguments[i] !== nil) {
-                result       = false;
-                $breaker.$v = nil;
+        };
+      }
 
-                return $breaker;
-              }
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def one?(&block)
+    %x{
+      var result = false;
+
+      if (block !== nil) {
+        self.$each._p = function() {
+          var value = $opal.$yieldX(block, arguments);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
+
+          if (#{Opal.truthy?(`value`)}) {
+            if (result === true) {
+              result = false;
+              return $breaker;
             }
+
+            result = true;
           }
-        };
+        }
       }
+      else {
+        self.$each._p = function() {
+          var value = #{Opal.destructure(`arguments`)};
 
-      #{self}.$each._p = proc;
-      #{self}.$each();
+          if (#{Opal.truthy?(`value`)}) {
+            if (result === true) {
+              result = false;
+              return $breaker;
+            }
+
+            result = true;
+          }
+        }
+      }
+
+      self.$each();
 
       return result;
     }
   end
 
+  def slice_before(pattern = undefined, &block)
+    if `pattern === undefined && block === nil || arguments.length > 1`
+      raise ArgumentError, "wrong number of arguments (#{`arguments.length`} for 1)"
+    end
+
+    Enumerator.new {|e|
+      %x{
+        var slice = [];
+
+        if (block !== nil) {
+          if (pattern === undefined) {
+            self.$each._p = function() {
+              var param = #{Opal.destructure(`arguments`)},
+                  value = $opal.$yield1(block, param);
+
+              if (#{Opal.truthy?(`value`)} && slice.length > 0) {
+                #{e << `slice`};
+                slice = [];
+              }
+
+              slice.push(param);
+            };
+          }
+          else {
+            self.$each._p = function() {
+              var param = #{Opal.destructure(`arguments`)},
+                  value = block(param, #{pattern.dup});
+
+              if (#{Opal.truthy?(`value`)} && slice.length > 0) {
+                #{e << `slice`};
+                slice = [];
+              }
+
+              slice.push(param);
+            };
+          }
+        }
+        else {
+          self.$each._p = function() {
+            var param = #{Opal.destructure(`arguments`)},
+                value = #{pattern === `param`};
+
+            if (#{Opal.truthy?(`value`)} && slice.length > 0) {
+              #{e << `slice`};
+              slice = [];
+            }
+
+            slice.push(param);
+          };
+        }
+
+        self.$each();
+
+        if (slice.length > 0) {
+          #{e << `slice`};
+        }
+      }
+    }
+  end
+
   def sort_by(&block)
-    map { |*f|
-      # FIXME: this should probably belongs to somewhere more
-      f = `#{f}.length === 1 ? #{f}[0] : #{f}`
-      `[#{block.call(f)}, #{f}]`
-    }.sort.map { |f| `#{f}[1]` }
+    return enum_for :sort_by unless block_given?
+
+    map {
+      arg = Opal.destructure(`arguments`)
+
+      [block.call(arg), arg]
+    }.sort { |a, b| a[0] <=> b[0] }.map { |arg| `arg[1]` }
   end
 
   alias select find_all
 
-  alias take first
+  alias reduce inject
 
-  alias to_a entries
+  def take(num)
+    first(num)
+  end
+
+  def take_while(&block)
+    return enum_for :take_while unless block
 
-  alias inject reduce
+    %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`)}) {
+          return $breaker;
+        }
+
+        result.push(param);
+      };
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  alias to_a entries
 end