opal-cj 0.7.0.beta1

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.$$class = 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.$$is_array) {
+        return #{self.class.allocate(`result`)}
+      }
+      else {
+        return result;
+      }
+    }
+  end
+
+  def [](index, length = undefined)
+    %x{
+      var result = #{@literal.slice(index, length)};
+
+      if (result.$$is_array && (index.$$is_range || 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

@@ -0,0 +1,73 @@
+class BasicObject
+  def initialize(*)
+  end
+
+  def ==(other)
+    `self === other`
+  end
+
+  def __id__
+    `self.$$id || (self.$$id = Opal.uid())`
+  end
+
+  def __send__(symbol, *args, &block)
+    %x{
+      var func = self['$' + symbol]
+
+      if (func) {
+        if (block !== nil) {
+          func.$$p = block;
+        }
+
+        return func.apply(self, args);
+      }
+
+      if (block !== nil) {
+        self.$method_missing.$$p = block;
+      }
+
+      return self.$method_missing.apply(self, [symbol].concat(args));
+    }
+  end
+
+  def !
+    false
+  end
+
+  alias eql? ==
+  alias equal? ==
+
+  def instance_eval(&block)
+    Kernel.raise ArgumentError, "no block given" unless block
+
+    %x{
+      var old = block.$$s,
+          result;
+
+      block.$$s = null;
+      result = block.call(self, self);
+      block.$$s = old;
+
+      return result;
+    }
+  end
+
+  def instance_exec(*args, &block)
+    Kernel.raise ArgumentError, "no block given" unless block
+
+    %x{
+      var block_self = block.$$s,
+          result;
+
+      block.$$s = null;
+      result = block.apply(self, args);
+      block.$$s = block_self;
+
+      return result;
+    }
+  end
+
+  def method_missing(symbol, *args, &block)
+    Kernel.raise NoMethodError, "undefined method `#{symbol}' for BasicObject instance"
+  end
+end

data/opal/corelib/boolean.rb

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

data/opal/corelib/class.rb

@@ -0,0 +1,55 @@
+require 'corelib/module'
+
+class Class
+  def self.new(sup = Object, &block)
+    %x{
+      if (!sup.$$is_class || sup.$$is_mod) {
+        #{raise TypeError, "superclass must be a Class"};
+      }
+
+      function AnonClass(){};
+      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);
+
+      if (block !== nil) {
+        var block_self = block.$$s;
+        block.$$s = null;
+        block.call(klass);
+        block.$$s = block_self;
+      }
+
+      return klass;
+    }
+  end
+
+  def allocate
+    %x{
+      var obj = new self.$$alloc;
+      obj.$$id = Opal.uid();
+      return obj;
+    }
+  end
+
+  def inherited(cls)
+  end
+
+  def new(*args, &block)
+    %x{
+      var obj = #{allocate};
+
+      obj.$initialize.$$p = block;
+      obj.$initialize.apply(obj, args);
+      return obj;
+    }
+  end
+
+  def superclass
+    `self.$$super || nil`
+  end
+end

data/opal/corelib/comparable.rb

@@ -0,0 +1,56 @@
+module Comparable
+  def self.normalize(what)
+    return what if Integer === what
+
+    return  1 if what > 0
+    return -1 if what < 0
+    return  0
+  end
+
+  def ==(other)
+    return true if equal?(other)
+
+    return false unless cmp = (self <=> other)
+    return Comparable.normalize(cmp) == 0
+  rescue StandardError
+    false
+  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 <(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)
+    return false if self < min
+    return false if self > max
+    return true
+  end
+end

data/opal/corelib/complex.rb

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

data/opal/corelib/dir.rb

@@ -0,0 +1,20 @@
+class Dir
+  class << self
+    def chdir(dir)
+      prev_cwd = `$opal.current_dir`
+      `$opal.current_dir = #{dir}`
+      yield
+    ensure
+      `$opal.current_dir = #{prev_cwd}`
+    end
+
+    def pwd
+      `$opal.current_dir` || '.'
+    end
+    alias getwd pwd
+
+    def home
+      ENV['HOME'] || '.'
+    end
+  end
+end

data/opal/corelib/enumerable.rb

@@ -0,0 +1,1132 @@
+module Enumerable
+  def all?(&block)
+    %x{
+      var result = true;
+
+      if (block !== nil) {
+        self.$each.$$p = function() {
+          var value = $opal.$yieldX(block, arguments);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
+
+          if (#{Opal.falsy?(`value`)}) {
+            result = false;
+            return $breaker;
+          }
+        }
+      }
+      else {
+        self.$each.$$p = function(obj) {
+          if (arguments.length == 1 && #{Opal.falsy?(`obj`)}) {
+            result = false;
+            return $breaker;
+          }
+        }
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def any?(&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`)}) {
+            result = true;
+            return $breaker;
+          }
+        };
+      }
+      else {
+        self.$each.$$p = function(obj) {
+          if (arguments.length != 1 || #{Opal.truthy?(`obj`)}) {
+            result = true;
+            return $breaker;
+          }
+        }
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def chunk(state = undefined, &block)
+    raise NotImplementedError
+  end
+
+  def collect(&block)
+    return enum_for :collect unless block_given?
+
+    %x{
+      var result = [];
+
+      self.$each.$$p = function() {
+        var value = $opal.$yieldX(block, arguments);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        result.push(value);
+      };
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def collect_concat(&block)
+    return enum_for :collect_concat unless block_given?
+    map { |item| yield item }.flatten(1)
+  end
+
+  def count(object = undefined, &block)
+    %x{
+      var result = 0;
+
+      if (object != null) {
+        block = function() {
+          return #{Opal.destructure(`arguments`) == `object`};
+        };
+      }
+      else if (block === nil) {
+        block = function() { return true; };
+      }
+
+      self.$each.$$p = function() {
+        var value = $opal.$yieldX(block, arguments);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        if (#{Opal.truthy?(`value`)}) {
+          result++;
+        }
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def cycle(n = nil, &block)
+    return enum_for :cycle, n unless block
+
+    unless n.nil?
+      n = Opal.coerce_to! n, Integer, :to_int
+
+      return if `n <= 0`
+    end
+
+    %x{
+      var result,
+          all  = [];
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = $opal.$yield1(block, param);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        all.push(param);
+      }
+
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
+
+      if (all.length === 0) {
+        return nil;
+      }
+    }
+
+    if n.nil?
+      %x{
+        while (true) {
+          for (var i = 0, length = all.length; i < length; i++) {
+            var value = $opal.$yield1(block, all[i]);
+
+            if (value === $breaker) {
+              return $breaker.$v;
+            }
+          }
+        }
+      }
+    else
+      %x{
+        while (n > 1) {
+          for (var i = 0, length = all.length; i < length; i++) {
+            var value = $opal.$yield1(block, all[i]);
+
+            if (value === $breaker) {
+              return $breaker.$v;
+            }
+          }
+
+          n--;
+        }
+      }
+    end
+  end
+
+  def detect(ifnone = undefined, &block)
+    return enum_for :detect, ifnone unless block_given?
+
+    %x{
+      var result = undefined;
+
+      self.$each.$$p = function() {
+        var params = #{Opal.destructure(`arguments`)},
+            value  = $opal.$yield1(block, params);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        if (#{Opal.truthy?(`value`)}) {
+          result = params;
+          return $breaker;
+        }
+      };
+
+      self.$each();
+
+      if (result === undefined && ifnone !== undefined) {
+        if (typeof(ifnone) === 'function') {
+          result = ifnone();
+        }
+        else {
+          result = 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() {
+        if (number <= current) {
+          result.push(#{Opal.destructure(`arguments`)});
+        }
+
+        current++;
+      };
+
+      self.$each()
+
+      return result;
+    }
+  end
+
+  def drop_while(&block)
+    return enum_for :drop_while unless block_given?
+
+    %x{
+      var result   = [],
+          dropping = true;
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)};
+
+        if (dropping) {
+          var value = $opal.$yield1(block, param);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
+
+          if (#{Opal.falsy?(`value`)}) {
+            dropping = false;
+            result.push(param);
+          }
+        }
+        else {
+          result.push(param);
+        }
+      };
+
+      self.$each();
+
+      return result;
+    }
+  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
+
+    if `n <= 0`
+      raise ArgumentError, 'invalid slice size'
+    end
+
+    return enum_for :each_slice, n unless block_given?
+
+    %x{
+      var result,
+          slice = []
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)};
+
+        slice.push(param);
+
+        if (slice.length === n) {
+          if ($opal.$yield1(block, slice) === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
+
+          slice = [];
+        }
+      };
+
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
+
+      // our "last" group, if smaller than n then won't have been yielded
+      if (slice.length > 0) {
+        if ($opal.$yield1(block, slice) === $breaker) {
+          return $breaker.$v;
+        }
+      }
+    }
+
+    nil
+  end
+
+  def each_with_index(*args, &block)
+    return enum_for :each_with_index, *args unless block_given?
+
+    %x{
+      var result,
+          index = 0;
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = block(param, index);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+
+        index++;
+      };
+
+      self.$each.apply(self, args);
+
+      if (result !== undefined) {
+        return result;
+      }
+    }
+
+    self
+  end
+
+  def each_with_object(object, &block)
+    return enum_for :each_with_object, object unless block_given?
+
+    %x{
+      var result;
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)},
+            value = block(param, object);
+
+        if (value === $breaker) {
+          result = $breaker.$v;
+          return $breaker;
+        }
+      };
+
+      self.$each();
+
+      if (result !== undefined) {
+        return result;
+      }
+    }
+
+    object
+  end
+
+  def entries(*args)
+    %x{
+      var result = [];
+
+      self.$each.$$p = function() {
+        result.push(#{Opal.destructure(`arguments`)});
+      };
+
+      self.$each.apply(self, args);
+
+      return result;
+    }
+  end
+
+  alias find detect
+
+  def find_all(&block)
+    return enum_for :find_all 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.truthy?(`value`)}) {
+          result.push(param);
+        }
+      };
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def find_index(object = undefined, &block)
+    return enum_for :find_index if `object === undefined && block === nil`
+
+    %x{
+      var result = nil,
+          index  = 0;
+
+      if (object != null) {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)};
+
+          if (#{`param` == `object`}) {
+            result = index;
+            return $breaker;
+          }
+
+          index += 1;
+        };
+      }
+      else 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`)}) {
+            result = index;
+            return $breaker;
+          }
+
+          index += 1;
+        };
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def first(number = undefined)
+    if `number === undefined`
+      result = nil
+
+      %x{
+        self.$each.$$p = function() {
+          result = #{Opal.destructure(`arguments`)};
+
+          return $breaker;
+        };
+
+        self.$each();
+      }
+    else
+      result = []
+      number = Opal.coerce_to number, Integer, :to_int
+
+      if `number < 0`
+        raise ArgumentError, 'attempt to take negative size'
+      end
+
+      if `number == 0`
+        return []
+      end
+
+      %x{
+        var current = 0,
+            number  = #{Opal.coerce_to number, Integer, :to_int};
+
+        self.$each.$$p = function() {
+          result.push(#{Opal.destructure(`arguments`)});
+
+          if (number <= ++current) {
+            return $breaker;
+          }
+        };
+
+        self.$each();
+      }
+    end
+
+    result
+  end
+
+  alias flat_map collect_concat
+
+  def grep(pattern, &block)
+    %x{
+      var result = [];
+
+      if (block !== nil) {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)},
+              value = #{pattern === `param`};
+
+          if (#{Opal.truthy?(`value`)}) {
+            value = $opal.$yield1(block, param);
+
+            if (value === $breaker) {
+              result = $breaker.$v;
+              return $breaker;
+            }
+
+            result.push(value);
+          }
+        };
+      }
+      else {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)},
+              value = #{pattern === `param`};
+
+          if (#{Opal.truthy?(`value`)}) {
+            result.push(param);
+          }
+        };
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def group_by(&block)
+    return enum_for :group_by unless block_given?
+
+    hash = Hash.new
+
+    %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
+
+  def include?(obj)
+    %x{
+      var result = false;
+
+      self.$each.$$p = function() {
+        var param = #{Opal.destructure(`arguments`)};
+
+        if (#{`param` == obj}) {
+          result = true;
+          return $breaker;
+        }
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def inject(object = undefined, sym = undefined, &block)
+    %x{
+      var result = object;
+
+      if (block !== nil && sym === undefined) {
+        self.$each.$$p = function() {
+          var value = #{Opal.destructure(`arguments`)};
+
+          if (result === undefined) {
+            result = value;
+            return;
+          }
+
+          value = $opal.$yieldX(block, [result, value]);
+
+          if (value === $breaker) {
+            result = $breaker.$v;
+            return $breaker;
+          }
+
+          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`};
+        };
+      }
+
+      self.$each();
+
+      return result == undefined ? nil : result;
+    }
+  end
+
+  def lazy
+    Enumerator::Lazy.new(self, enumerator_size) {|enum, *args|
+      enum.yield(*args)
+    }
+  end
+
+  def enumerator_size
+    respond_to?(:size) ? size : nil
+  end
+  private :enumerator_size
+
+  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 (value === nil) {
+            #{raise ArgumentError, "comparison failed"};
+          }
+
+          if (value > 0) {
+            result = param;
+          }
+        };
+      }
+      else {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)};
+
+          if (result === undefined) {
+            result = param;
+            return;
+          }
+
+          if (#{Opal.compare(`param`, `result`)} > 0) {
+            result = param;
+          }
+        };
+      }
+
+      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 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 (value === nil) {
+            #{raise ArgumentError, "comparison failed"};
+          }
+
+          if (value < 0) {
+            result = param;
+          }
+        };
+      }
+      else {
+        self.$each.$$p = function() {
+          var param = #{Opal.destructure(`arguments`)};
+
+          if (result === undefined) {
+            result = param;
+            return;
+          }
+
+          if (#{Opal.compare(`param`, `result`)} < 0) {
+            result = param;
+          }
+        };
+      }
+
+      self.$each();
+
+      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);
+
+        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 minmax(&block)
+    raise NotImplementedError
+  end
+
+  def minmax_by(&block)
+    raise NotImplementedError
+  end
+
+  def none?(&block)
+    %x{
+      var result = true;
+
+      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`)}) {
+            result = false;
+            return $breaker;
+          }
+        }
+      }
+      else {
+        self.$each.$$p = function() {
+          var value = #{Opal.destructure(`arguments`)};
+
+          if (#{Opal.truthy?(`value`)}) {
+            result = false;
+            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`)};
+
+          if (#{Opal.truthy?(`value`)}) {
+            if (result === true) {
+              result = false;
+              return $breaker;
+            }
+
+            result = true;
+          }
+        }
+      }
+
+      self.$each();
+
+      return result;
+    }
+  end
+
+  def partition(&block)
+    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)
+    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
+
+  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(&block)
+    raise NotImplementedError
+  end
+
+  def sort_by(&block)
+    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
+
+  def take(num)
+    first(num)
+  end
+
+  def take_while(&block)
+    return enum_for :take_while unless block
+
+    %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
+
+  def zip(*others, &block)
+    to_a.zip(*others)
+  end
+end