opal-wedge 0.9.0.dev

data/opal/corelib/array/inheritance.rb

@@ -0,0 +1,127 @@
+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.$$is_array = true`
+
+  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
+
+  def hash
+    @literal.hash
+  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
+
+  def -(other)
+    @literal - other
+  end
+
+  def +(other)
+    @literal + other
+  end
+end

data/opal/corelib/basic_object.rb

@@ -0,0 +1,82 @@
+class BasicObject
+  def initialize(*)
+  end
+
+  def ==(other)
+    `self === other`
+  end
+
+  def eql?(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
+
+  def !=(other)
+    !(self == other)
+  end
+
+  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, `self.$inspect && !self.$inspect.$$stub` ?
+      "undefined method `#{symbol}' for #{inspect}:#{`self.$$class`}" :
+      "undefined method `#{symbol}' for #{`self.$$class`}"
+  end
+end

data/opal/corelib/boolean.rb

@@ -0,0 +1,47 @@
+class Boolean
+  `def.$$is_boolean = true`
+
+  def __id__
+    `self.valueOf() ? 2 : 0`
+  end
+  alias object_id __id__
+
+  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 eql? ==
+
+  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,57 @@
+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,1138 @@
+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){self.enumerator_size} 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){self.enumerator_size} 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) {
+      if n == nil
+        respond_to?(:size) ? Float::INFINITY : nil
+      else
+        n = Opal.coerce_to!(n, Integer, :to_int)
+        n > 0 ? self.enumerator_size * n : 0
+      end
+    } unless block_given?
+
+    unless n.nil?
+      n = Opal.coerce_to! n, Integer, :to_int
+
+      return if `n <= 0`
+    end
+
+    %x{
+      var result,
+          all = [], i, length, value;
+
+      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) {
+        while (true) {
+          for (i = 0, length = all.length; i < length; i++) {
+            value = Opal.yield1(block, all[i]);
+
+            if (value === $breaker) {
+              return $breaker.$v;
+            }
+          }
+        }
+      }
+      else {
+        while (n > 1) {
+          for (i = 0, length = all.length; i < length; i++) {
+            value = Opal.yield1(block, all[i]);
+
+            if (value === $breaker) {
+              return $breaker.$v;
+            }
+          }
+
+          n--;
+        }
+      }
+    }
+  end
+
+  def detect(ifnone = undefined, &block)
+    return enum_for :detect, ifnone unless block_given?
+
+    %x{
+      var result;
+
+      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){respond_to?(:size) ? (size / n).ceil : nil} 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){self.enumerator_size} 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){self.enumerator_size} 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){self.enumerator_size} 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){self.enumerator_size} 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){self.enumerator_size} 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){self.enumerator_size} 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){self.enumerator_size} unless block_given?
+
+    %x{
+      var truthy = [], falsy = [], 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`)}) {
+          truthy.push(param);
+        }
+        else {
+          falsy.push(param);
+        }
+      };
+
+      self.$each();
+
+      return [truthy, falsy];
+    }
+  end
+
+  alias reduce inject
+
+  def reject(&block)
+    return enum_for(:reject){self.enumerator_size} 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){self.enumerator_size} 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)
+    ary = to_a
+    block = -> a,b {a <=> b} unless block_given?
+    return `ary.sort(block)`
+  end
+
+  def sort_by(&block)
+    return enum_for(:sort_by){self.enumerator_size} 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