backports 1.3.1 → 1.5.0

data/CHANGELOG.rdoc

@@ -1,5 +1,34 @@
 = Packable --- History
 
+== Version 1.5 - April 24, 2009
+
+* Array (completed)
+  * +combination+
+  * +try_convert+
+  * Optional block for collect!, :map!, :each, :each_index, :reject, :reject!, :delete_if
+  * +pop+, +shift+
+  * +product+
+
+* Fixnum (completed)
+  * +div+, +fdiv+
+  * +succ+
+  * +magnitude+
+
+* Enumerable (completed)
+  * +each_with_object+
+  * +inject+
+  * +max_by+, +min_by+, +minmax+, +minmax_by+
+  * +reduce+
+  * +to_a+
+
+== Version 1.4 - April 21, 2009
+
+* String
+  * +rpartition+
+
+* Proc
+  * +yield+
+
 == Version 1.3 - April 17, 2009
 
 * Enumerable

data/README.rdoc

@@ -47,28 +47,20 @@ Compatible with Ruby 1.8 & 1.9.
   * +constantize+
   * +partition+, +rpartition+
 * Hash
-  * <tt>Hash[[[:foo, :bar],[:hello, "world"]]] ==> {:foo => :bar, :hello => "world"}</tt> (see _note_)
-  * +key+
   * +symbolize_keys+, <tt>symbolize_keys!</tt>
   * +reverse_merge+, <tt>reverse_merge!</tt>
+  * <tt>Hash[[[:foo, :bar],[:hello, "world"]]] ==> {:foo => :bar, :hello => "world"}</tt> (see _note_)
+  * +key+
   * <tt>default_proc=</tt>
 * Enumerable
   * +sum+
-  * +find_index+
-  * +take+, +take_while+, +drop+, +drop_while+
-  * +first+
-  * +reverse_each+
-  * +count+
-  * +cycle+
-  * +group_by+
-  * <tt>none?</tt>
+  * complete Ruby 1.8.7 backport
 * Array
-  * +flatten+, <tt>flatten!</tt>
-  * +find_index+, +find+
-  * +reverse_each+
-  * +cycle+
+  * complete Ruby 1.8.7 backport
 * Fixnum
-  * <tt>odd?</tt>, <tt>even?</tt>
+  * complete Ruby 1.8.7 backport
+* Proc
+  * +yield+
 
 Finally, there is no need to <tt>require 'enumerator'</tt> in older Ruby, and +Enumerator+ can be accessed directly (instead of <tt>Enumerable::Enumerator</tt>)
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 1
-:minor: 3
-:patch: 1
+:minor: 5
+:patch: 0

data/lib/backports.rb

@@ -10,6 +10,6 @@ module Kernel
   end unless method_defined? :require_relative
 end
 
-%w(object module array enumerable string symbol fixnum hash).each do |lib|
+%w(object module array enumerable string symbol fixnum hash proc).each do |lib|
   require_relative "backports/#{lib}"
 end

data/lib/backports/array.rb

@@ -1,4 +1,52 @@
 class Array
+  class << self
+    # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
+    def try_convert(x)
+      x.to_ary if x.respond_to? :to_ary
+    end unless method_defined? :try_convert
+  end
+
+  # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
+  unless ([42].map! rescue false)
+    # Make block optional for...
+    [:collect!, :map!, :each, :each_index, :reverse_each, :reject, :reject!, :delete_if].each do |selector|
+      alias_method_chain(selector, :optional_block) do |aliased_target, punctuation|
+        module_eval <<-end_eval
+          def #{aliased_target}_with_optional_block#{punctuation}(*args, &block)
+            return to_enum(:#{aliased_target}_without_optional_block#{punctuation}, *args) unless block_given?
+            #{aliased_target}_without_optional_block#{punctuation}(*args, &block)
+          end
+        end_eval
+      end
+    end
+  end
+  
+  # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
+  def combination(num)
+    num = num.to_i
+    return to_enum(:combination, num) unless block_given?
+    return self unless (0..size).include? num
+    # Implementation note: slightly tricky.
+                                             # Example: self = 1..7, num = 3
+    picks = (0...num).to_a                   # picks start at 0, 1, 2
+    max = ((size-num)...size).to_a           # max (index for a given pick) is [4, 5, 6]
+    pick_max_pairs = picks.zip(max).reverse  # pick_max_pairs = [[2, 6], [1, 5], [0, 4]]
+    lookup = pick_max_pairs.find(Proc.new{return self})
+    loop do
+      yield values_at(*picks)
+      move = lookup.each{|pick, max| picks[pick] < max}.first
+      new_index = picks[move] + 1
+      picks[move...num] = (new_index...(new_index+num-move)).to_a
+    end
+  end unless method_defined? :combination
+  
+  # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
+  def cycle(*arg, &block)
+    return to_enum(:cycle, *arg) unless block_given?
+    nb = arg.empty? ? (1/0.0) : arg.first
+    nb.to_i.times{each(&block)}
+  end unless method_defined? :cycle
+  
   # flatten & flatten!, standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
   unless ([[]].flatten(1) rescue false)
 
@@ -57,6 +105,30 @@ class Array
     alias_method :find_index, :index
   end
   
+  # pop. Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
+  unless ([1].pop(1) rescue false)
+    def pop_with_optional_argument(*arg)
+      return pop_without_optional_argument if arg.empty?
+      n = arg.first.to_i
+      slice!([0,size-n].max, size)
+    end
+    alias_method_chain :pop, :optional_argument
+  end
+  
+  def product(*arg)
+    arg.unshift(self)
+    arg._partial_cartesian_product(arg.size-1, Array.new(arg.size), [])
+  end unless method_defined? :product
+  
+  def _partial_cartesian_product(combi, iterate_index, result)
+    action = iterate_index.zero? ? Proc.new(result << combi.dup) : Proc.new(_sub(combi, iterate_index-1, &block))
+    self[iterate_index].each do |obj|
+      combi[iterate_index] = obj
+      action.call
+    end
+  end
+  private :_partial_cartesian_product
+  
   # rindex
   unless ([1].rindex{true} rescue false)
     def rindex_with_block(*arg)
@@ -66,20 +138,17 @@ class Array
     end
     alias_method_chain :rindex, :block
   end
-
-  unless ([1].reverse_each rescue false)
-    def reverse_each_with_optional_block(&block)
-      return reverse_each_without_optional_block(&block) if block_given?
-      to_enum(:reverse_each)
+  
+  # shift. Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html]
+  unless ([1].shift(1) rescue false)
+    def shift_with_optional_argument(*arg)
+      return shift_without_optional_argument if arg.empty?
+      n = arg.first.to_i
+      slice!(0, n)
     end
-    alias_method_chain :reverse_each, :optional_block
+    alias_method_chain :shift, :optional_argument
   end
   
-  def cycle(*arg, &block)
-    return to_enum(:cycle, *arg) unless block_given?
-    nb = arg.empty? ? (1/0.0) : arg.first
-    nb.to_i.times{each(&block)}
-  end unless method_defined? :cycle
   
   def sample(*arg)
     return self[rand(size)] if arg.empty?

data/lib/backports/enumerable.rb

@@ -10,42 +10,35 @@ module Enumerable
   end unless method_defined? :sum
 
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def find_index(*args)
-    if args.size == 1
-      obj = args.first
-      each_with_index do |element, i|
-        return i if element == obj
-      end
-    elsif block_given?
-      each_with_index do |element, i|
-        return i if yield element
-      end
-      each_with_index{|o,i| return i if yield o}
+  def count(*arg)
+    result = 0
+    if block_given?
+      each{|o| result += 1 if yield o}
+    elsif arg.empty?
+      each{|o| result += 1}
     else
-      raise ArgumentError, "Wrong number of arguments (#{args.size} for 1)"
+      obj = arg.first
+      each{|o| result += 1 if obj == o}
     end
-    nil
-  end unless method_defined? :find_index
+    result
+  end unless method_defined? :count
   
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def take(n)
-    returning([]) do |array|
-      each do |elem|
-        array << elem
-        break if array.size >= n
-      end unless n <= 0
-    end
-  end unless method_defined? :take
+  def cycle(*arg, &block)
+    return to_enum(:cycle, *arg) unless block_given?
+    to_a.cycle(*arg, &block)
+  end unless method_defined? :cycle
   
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def take_while
-    return to_enum(:take_while) unless block_given?
-    inject([]) do |array, elem|
-      return array unless yield elem
-      array << elem
+  unless ([].detect rescue false)
+    def detect_with_optional_block(ifnone = nil, &block)
+      return to_enum(:detect, ifnone) unless block_given?
+      detect_without_optional_block(ifnone, &block)
     end
-  end unless method_defined? :take_while
-
+    alias_method_chain :detect, :optional_block
+    alias_method :find, :detect
+  end
+  
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
   def drop(n)
     array = to_a
@@ -63,18 +56,15 @@ module Enumerable
   end unless method_defined? :drop_while
   
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def first(*arg)
-      arg.empty? ? take(1)[0] : take(arg.first)
-  end unless method_defined? :first
+  unless ((1..2).each_cons(1) rescue false)
+    def each_cons_with_optional_block(len, &block)
+      raise ArgumentError, "invalid size" if len <= 0
+      return to_enum(:each_cons, len) unless block_given?
+      each_cons_without_optional_block(len, &block)
+    end
+    alias_method_chain :each_cons, :optional_block
+  end
 
-  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def reverse_each(&block)
-    return to_enum(:reverse_each) unless block_given?
-    # There is no other way then to convert to an array first... see 1.9's source.
-    to_a.reverse_each(&block)
-    self
-  end unless method_defined? :reverse_each
-  
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
   unless ((1..2).each_slice(1) rescue false)
     def each_slice_with_optional_block(len, &block)
@@ -84,36 +74,45 @@ module Enumerable
     end
     alias_method_chain :each_slice, :optional_block
   end
-  
+
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def count(*arg)
-    result = 0
-    if block_given?
-      each{|o| result += 1 if yield o}
-    elsif arg.empty?
-      each{|o| result += 1}
-    else
-      obj = arg.first
-      each{|o| result += 1 if obj == o}
+  if instance_method(:each_with_index).arity.zero?
+    def each_with_index_with_optional_args_and_block(*args, &block)
+      return to_enum(:each_with_index, *args) unless block_given?
+      to_enum(:each, *args).each_with_index_without_optional_args_and_block(&block)
     end
-    result
-  end unless method_defined? :count
+    alias_method_chain :each_with_index, :optional_args_and_block
+  end
   
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  def cycle(*arg, &block)
-    return to_enum(:cycle, *arg) unless block_given?
-    to_a.cycle(*arg, &block)
-  end unless method_defined? :cycle
-  
+  def each_with_object(memo, &block)
+    return to_enum(:each_with_object, memo) unless block_given?
+    each {|obj| block.call(obj, memo)}
+    memo
+  end unless method_defined? :each_with_object
+
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
-  unless ((1..2).each_cons(1) rescue false)
-    def each_cons_with_optional_block(len, &block)
-      raise ArgumentError, "invalid size" if len <= 0
-      return to_enum(:each_cons, len) unless block_given?
-      each_cons_without_optional_block(len, &block)
+  def find_index(*args)
+    if args.size == 1
+      obj = args.first
+      each_with_index do |element, i|
+        return i if element == obj
+      end
+    elsif block_given?
+      each_with_index do |element, i|
+        return i if yield element
+      end
+      each_with_index{|o,i| return i if yield o}
+    else
+      raise ArgumentError, "Wrong number of arguments (#{args.size} for 1)"
     end
-    alias_method_chain :each_cons, :optional_block
-  end
+    nil
+  end unless method_defined? :find_index
+  
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def first(*arg)
+    arg.empty? ? take(1)[0] : take(arg.first)
+  end unless method_defined? :first
 
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
   def group_by
@@ -125,9 +124,122 @@ module Enumerable
     end
   end unless method_defined? :group_by
   
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  unless ((1..2).inject(:+) rescue false)
+    def inject_with_symbol(*args, &block)
+      return inject_without_symbol(*args, &block) if block_given?
+      method = args.pop
+      raise TypeError, "#{method} is not a symbol" unless method.respond_to? :to_sym
+      method = method.to_sym
+      inject_without_symbol(*args) {|memo, obj| memo.send(method, obj)}
+    end
+    alias_method_chain :inject, :symbol
+  end
+  
+  MOST_EXTREME_OBJECT_EVER = Object.new # :nodoc:
+  class << MOST_EXTREME_OBJECT_EVER
+    def < (whatever)
+      true
+    end
+
+    def > (whatever)
+      true
+    end
+  end
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def max_by(&block)
+    return to_enum(:max_by) unless block_given?
+    minmax_by(&block)[1]
+  end unless method_defined? :max_by
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def min_by(&block)
+    return to_enum(:min_by) unless block_given?
+    minmax_by(&block).first
+  end unless method_defined? :min_by
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def minmax
+    return minmax{|a,b| a <=> b} unless block_given?
+    first_time = true
+    min, max = nil
+    each do |object|
+      if first_time
+        min = max = object
+        first_time = false
+      else
+        min = object if yield(min, object) > 0
+        max = object if yield(max, object) < 0
+      end
+    end
+    [min, max]
+  end unless method_defined? :minmax
+  
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def minmax_by(&block)
+    return to_enum(:minmax_by) unless block_given?
+    min_object, min_result = nil, MOST_EXTREME_OBJECT_EVER
+    max_object, max_result = nil, MOST_EXTREME_OBJECT_EVER
+    each do |object|
+      result = yield object
+      min_object, min_result = object, result if min_result > result
+      max_object, max_result = object, result if max_result < result
+    end
+    [min_object, max_object]
+  end unless method_defined? :minmax_by
+
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
   def none?(&block)
     !any?(&block)
   end unless method_defined? :none?
 
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def one?(&block)
+    return one?{|o| o} unless block_given?
+    1 == count(&block)
+  end unless method_defined? :one?
+
+  alias_method :reduce, :inject unless method_defined? :reduce
+  
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def reverse_each(&block)
+    return to_enum(:reverse_each) unless block_given?
+    # There is no other way then to convert to an array first... see 1.9's source.
+    to_a.reverse_each(&block)
+    self
+  end unless method_defined? :reverse_each
+  
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def take(n)
+    returning([]) do |array|
+      each do |elem|
+        array << elem
+        break if array.size >= n
+      end unless n <= 0
+    end
+  end unless method_defined? :take
+  
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  def take_while
+    return to_enum(:take_while) unless block_given?
+    inject([]) do |array, elem|
+      return array unless yield elem
+      array << elem
+    end
+  end unless method_defined? :take_while
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html]
+  if instance_method(:to_a).arity.zero?
+    def to_a_with_optional_arguments(*args)
+      return to_a_without_optional_arguments if args.empty?
+      to_enum(:each, *args).to_a
+    end
+    alias_method_chain :to_a, :optional_arguments
+  end
+  
 end
+
+class Enumerator
+  alias_method :with_object, :each_with_object unless method_defined? :with_object
+end

data/lib/backports/fixnum.rb

@@ -1,11 +1,33 @@
 class Fixnum
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Fixnum.html]
-  def odd?
-    self & 1 == 1
-  end unless method_defined? :odd?
-  
+  def div(n)
+    (self / n).round
+  end unless method_defined? :div
+
   # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Fixnum.html]
   def even?
     self & 1 == 0
   end unless method_defined? :even?
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Fixnum.html]
+  def fdiv(n)
+    to_f / n
+  end unless method_defined? :fdiv
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Fixnum.html]
+  def odd?
+    self & 1 == 1
+  end unless method_defined? :odd?
+
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Fixnum.html]
+  def succ
+    self + 1
+  end unless method_defined? :succ
+  
+  alias_method :magnitude, :abs unless method_defined? :magnitude
+  
+  
+  
+  
+  
 end

data/lib/backports/hash.rb

@@ -9,6 +9,11 @@ class Hash
         arg.first.each{|key, value| h[key] = value}
       end
     end unless (Hash[[[:test, :test]]] rescue false)
+    
+    def try_convert(x)
+      return nil unless x.respond_to? :to_hash
+      x.to_hash
+    end unless method_defined? :to_hash
   end
 
   # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html]

data/lib/backports/proc.rb

@@ -0,0 +1,4 @@
+class Proc
+  # Standard in ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Proc.html]
+  alias_method :yield, :call unless method_defined? :yield
+end

data/test/array_test.rb

@@ -2,17 +2,21 @@ require 'test_helper'
 
 class ArrayTest < Test::Unit::TestCase
   context "Array" do
-    context "#reverse_each" do
-      should "return an enumerator when no block is given" do
-        assert_equal [4,3,2], [1,2,3,4].reverse_each.take(3)
+    context "#combination" do
+      should "conform to doc" do
+        a = [ "a", "b", "c" ] 
+        assert_equal [["a"], ["b"], ["c"]], a.combination(1).to_a
+        assert_equal [["a", "b"], ["a", "c"], ["b", "c"]], a.combination(2).to_a 
+        assert_equal [["a", "b", "c"]], a.combination(3).to_a
+        assert_equal [], a.combination(4).to_a
       end
     end
-
+        
     context "#flatten" do
       should "conform to doc" do
-        s = [ 1, 2, 3 ]           #=> [1, 2, 3]
-        t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
-        a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
+        s = [ 1, 2, 3 ]
+        t = [ 4, 5, 6, [7, 8] ]
+        a = [ s, t, 9, 10 ]
         assert_equal [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], a.flatten
         a = [ 1, 2, [3, [4, 5] ] ]
         assert_equal [1, 2, 3, [4, 5]], a.flatten(1)
@@ -28,6 +32,30 @@ class ArrayTest < Test::Unit::TestCase
       end
     end
 
+    context "#reverse_each" do
+      should "return an enumerator when no block is given" do
+        assert_equal [4,3,2], [1,2,3,4].reverse_each.take(3)
+      end
+    end
+
+    context "#pop" do
+      should "conform to doc" do
+        a = %w{ f r a b j o u s } 
+        assert_equal "s", a.pop
+        assert_equal ["f", "r", "a", "b", "j", "o", "u"] , a
+        assert_equal ["j", "o", "u"], a.pop(3)
+        assert_equal ["f", "r", "a", "b"] , a
+      end
+    end
+    
+    context "#product" do
+      should "conform to doc" do
+        assert_equal  [[1, 3], [1, 4], [2, 3], [2, 4]], [1, 2].product([3, 4])
+        assert_equal [[1, 3, 5], [1, 4, 5], [2, 3, 5], [2, 4, 5]], [1, 2].product([3, 4], [5])
+        assert_equal [[1], [2]],  [1, 2].product
+      end
+    end
+    
     context "#sample" do
       should "conform to doc" do
         assert_equal nil, [].sample
@@ -38,7 +66,16 @@ class ArrayTest < Test::Unit::TestCase
         s = a.sample(2)
         assert_equal 2, s.size
         assert_equal 1, (a-s).size
-        assert_equal [], a-(0..20).sum{a.sample(2)} # ~ 3e-10
+        assert_equal [], a-(0..20).sum{a.sample(2)}
+      end
+    end
+    
+    context "#shift" do
+      should "conform to doc" do
+        args = [ "-m", "-q", "-v", "filename" ] 
+        assert_equal "-m", args.shift
+        assert_equal ["-q", "-v"], args.shift(2)
+        assert_equal ["filename"], args
       end
     end
   end

data/test/enumerable_test.rb

@@ -1,41 +1,22 @@
 require 'test_helper'
+require 'stringio'
 
 class EnumerableTest < Test::Unit::TestCase
   context "Enumerable" do
-    context "#find_index" do
+    context "#count" do
       should "conform to doc" do
-        assert_equal 3, %w{ant bat cat dog}.find_index {|item| item =~ /g/ }
-        assert_equal nil, %w{ant bat cat dog}.find_index {|item| item =~ /h/ }
-      end
-
-      should "#work for enumerables too" do
-        assert_equal 69-42, (42..666).find_index(69)
+        assert_equal 4, (1..4).count
+        assert_equal 1, (1..4).count(3)
+        assert_equal 2, (1..4).count{|obj| obj > 2 } 
       end
     end
 
-    context "#take" do
-      should "conform to doc" do
-        assert_equal [1, 2, 3], (1..7).take(3)
-        assert_equal [["a", 1], ["b", 2]], { 'a'=>1, 'b'=>2, 'c'=>3 }.take(2)
-      end
-    
-      should "only consume what's needed" do
-        assert_equal [], Enumerator.new(nil).take(0)
-        assert_raises(NoMethodError) { Enumerator.new(nil).take(1) }
-      end
-    end
-  
-    context "#take_while" do
+    context "#cycle" do
       should "conform to doc" do
-        assert_equal [1,2], (1..7).take_while {|item| item < 3 }
-        assert_equal [2,4,6], [ 2, 4, 6, 9, 11, 16 ].take_while(&:even?)
-      end
-
-      should "work with infinite enumerables" do
-        assert_equal [1,2], (1..(1/0.0)).take_while {|item| item < 3 }
+        assert_equal ["a", "b", "c", "a", "b", "c"], ('a'..'c').cycle(2).to_a
       end
     end
-  
+    
     context "#drop" do
       should "conform to doc" do
         assert_equal [5, 8, 13], [ 1, 1, 2, 3, 5, 8, 13 ].drop(4)
@@ -62,9 +43,9 @@ class EnumerableTest < Test::Unit::TestCase
       end
     end
     
-    context "#reverse_each" do
-      should "work as expected" do
-        assert_equal [4,3,2], (1..4).reverse_each.take(3)
+    context "#each_cons" do
+      should "conform to doc" do
+        assert_equal [[1,2],[2,3],[3,4]], (1..4).each_cons(2).to_a
       end
     end
     
@@ -76,27 +57,43 @@ class EnumerableTest < Test::Unit::TestCase
         assert_equal [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10]], (1..10).each_slice(4).to_a
       end
     end
-    
-    context "#count" do
+
+    context "#each_with_index" do
       should "conform to doc" do
-        assert_equal 4, (1..4).count
-        assert_equal 1, (1..4).count(3)
-        assert_equal 2, (1..4).count{|obj| obj > 2 } 
+        hash = Hash.new 
+        %w(cat dog wombat).each_with_index do |item, index| 
+          hash[item] = index 
+        end 
+        assert_equal({"cat"=>0, "wombat"=>2, "dog"=>1}, hash)
       end
+
+      should "be ok with arguments and no block" do
+        s = StringIO.new("Hello world!")
+        assert_equal [["Hello",0], [" wo",1], ["rld!",2]], s.each_with_index("o").to_a
+      end
+
     end
 
-    context "#cycle" do
+    context "#each_with_object" do
       should "conform to doc" do
-        assert_equal ["a", "b", "c", "a", "b", "c"], ('a'..'c').cycle(2).to_a
+        hash = %w(cat dog wombat).each_with_object({}) do |item, memo| 
+          memo[item] = item.upcase.reverse 
+        end 
+        assert_equal({"cat"=>"TAC", "dog"=>"GOD", "wombat"=>"TABMOW"}, hash)
       end
     end
-    
-    context "#each_cons" do
+
+    context "#find_index" do
       should "conform to doc" do
-        assert_equal [[1,2],[2,3],[3,4]], (1..4).each_cons(2).to_a
+        assert_equal 3, %w{ant bat cat dog}.find_index {|item| item =~ /g/ }
+        assert_equal nil, %w{ant bat cat dog}.find_index {|item| item =~ /h/ }
+      end
+
+      should "#work for enumerables too" do
+        assert_equal 69-42, (42..666).find_index(69)
       end
     end
-    
+
     context "#group_by" do
       should "conform to doc" do
         x = (1..5).group_by{|item| item.even? ? :even : :odd }
@@ -104,5 +101,83 @@ class EnumerableTest < Test::Unit::TestCase
         assert_equal nil, x[:xyz]
       end
     end
+
+    context "#inject" do
+      should "conform to doc" do
+        assert_equal 45, (5..10).inject(0) {|sum, n| sum + n }
+        assert_equal 45, (5..10).inject {|sum, n| sum + n }
+        assert_equal 45, (5..10).inject(0, :+)
+        assert_equal 45, (5..10).inject(:+)
+      end
+    end
+
+    context "#max_by" do
+      should "conform to doc" do
+        a = %w(albatross dog horse fox) 
+        assert_equal "albatross" , a.max_by {|item| item.length }
+        assert_equal "fox", a.max_by {|item| item.reverse }
+      end
+    end  
+
+    context "#min_by" do
+      should "conform to doc" do
+        a = %w(albatross dog horse fox) 
+        assert_equal "dog" , a.min_by {|item| item.length }
+        assert_equal "horse", a.min_by {|item| item.reverse }
+      end
+    end  
+
+    context "#minmax" do
+      should "conform to doc" do
+        a = %w(albatross dog horse) 
+        assert_equal ["albatross", "horse"], a.minmax
+        assert_equal ["dog", "albatross"], a.minmax {|a,b| a.length <=> b.length }
+      end
+    end
+    
+    context "#one" do
+      should "conform to doc" do
+        assert_equal false, %w{ ant bear cat}.one? {|word| word.length >= 3}
+        assert_equal true,  %w{ ant bear cat}.one? {|word| word.length >= 4}
+        assert_equal true,  [ nil, nil, 99 ].one?
+      end
+    end
+    
+    context "#reverse_each" do
+      should "work as expected" do
+        assert_equal [4,3,2], (1..4).reverse_each.take(3)
+      end
+    end
+        
+    context "#take" do
+      should "conform to doc" do
+        assert_equal [1, 2, 3], (1..7).take(3)
+        assert_equal [["a", 1], ["b", 2]], { 'a'=>1, 'b'=>2, 'c'=>3 }.take(2)
+      end
+    
+      should "only consume what's needed" do
+        assert_equal [], Enumerator.new(nil).take(0)
+        assert_raises(NoMethodError) { Enumerator.new(nil).take(1) }
+      end
+    end
+  
+    context "#take_while" do
+      should "conform to doc" do
+        assert_equal [1,2], (1..7).take_while {|item| item < 3 }
+        assert_equal [2,4,6], [ 2, 4, 6, 9, 11, 16 ].take_while(&:even?)
+      end
+
+      should "work with infinite enumerables" do
+        assert_equal [1,2], (1..(1/0.0)).take_while {|item| item < 3 }
+      end
+    end
+
+    context "#to_a" do
+      should "work with arguments" do
+        s = StringIO.new("Hello world!")
+        assert_equal ["Hello", " wo", "rld!"], s.to_a("o")
+      end
+    end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: backports
 version: !ruby/object:Gem::Version 
-  version: 1.3.1
+  version: 1.5.0
 platform: ruby
 authors: 
 - "Marc-Andr\xC3\xA9 Lafortune"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-20 00:00:00 -04:00
+date: 2009-04-24 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - lib/backports/hash.rb
 - lib/backports/module.rb
 - lib/backports/object.rb
+- lib/backports/proc.rb
 - lib/backports/string.rb
 - lib/backports/symbol.rb
 - test/array_test.rb