backports 2.8.2 → 3.0.0

data/CHANGELOG.rdoc

@@ -1,5 +1,16 @@
 = Backports --- History
 
+== Version 3.0.0 - February 24th, 2013
+
+* Features of 2.0.0 are now required when requiring 'backports'.
+
+* Additional features of 2.0.0
+  * Struct#to_h, NilClass#to_h, Hash#to_h
+  * Hash#default_proc = nil
+  * OpenStruct lib
+
+* 1.8.7's Enumerator#with_index (it wasn't in the 1.8.7 NEWS file...)
+
 == Version 2.8.0 - February 3rd, 2013
 
 * Added some features of 2.0.0 (must be required explicitly until official release):

data/README.rdoc

@@ -189,7 +189,7 @@ Some features of Ruby 1.9.3 have been backported:
   * +byteslice+
   * +prepend+
 
-To include all Ruby backports but not those of Rails, <tt>require "backports/1.9.3"</tt> (or "backports/1.9")
+To include all Ruby backports but not those of Ruby 2.0 or Rails, <tt>require "backports/1.9.3"</tt> (or "backports/1.9")
 
 == Ruby 2.0.0
 
@@ -201,10 +201,16 @@ Some features of Ruby 2.0.0 have been backported:
   * +lazy+
 * Enumerator::Lazy
   * all methods
+* Hash
+  * <tt>default_proc=</tt> (with nil argument)
+  * +to_h+
+* nil.to_h
 * Range
   * +bsearch+
+* Struct
+  * +to_h+
 
-*Note*: Ruby 2.0.0 will not included by default until 2.0.0 is released (and specs are thus finalized). To play around with these today, <tt>require "backports/2.0"</tt>.
+To include all Ruby backports but not those of Rails, <tt>require "backports/2.0"</tt> (or "backports/2.0.0")
 
 == Rails
 
@@ -245,7 +251,11 @@ The following libraries are up to date with Ruby 1.9.3:
 * Prime
 * Set
 
-I am aware of the following backport gem which will hopefully be part of backports soon:
+The following library is to date with Ruby 2.0.0:
+
+* OpenStruct (ostruct)
+
+I am aware of the following backport gem, which probably won't make it into this gem:
 
 * Net::SMTP for Ruby 1.8.6: smtp_tls[http://seattlerb.rubyforge.org/smtp_tls/]
 

data/lib/backports.rb

@@ -1,4 +1,4 @@
 require File.expand_path(File.dirname(__FILE__) + "/backports/tools")
 Backports.require_relative "backports/version"
-Backports.require_relative "backports/1.9"
+Backports.require_relative "backports/2.0"
 Backports.require_relative "backports/rails"

data/lib/backports/1.8.7/enumerator.rb

@@ -19,6 +19,14 @@ if (Enumerable::Enumerator rescue false)
         @generator.rewind
         self
       end unless method_defined? :rewind
+
+      def with_index(offset = 0)
+        to_enum :with_index, offset unless block_given?
+        each do |*args|
+          yield args.size == 1 ? args[0] : args, index
+          index += 1
+        end
+      end unless method_defined? :with_index
     end if const_defined? :Enumerator
   end
 end

data/lib/backports/1.9.1/enumerator.rb

@@ -20,7 +20,7 @@ class Enumerator
       end
     end
 
-    class Generator
+    class GeneratorBP # Avoid conflict with 1.8's ::Generator class
       def initialize(&block)
         @main_block = block
       end
@@ -32,7 +32,7 @@ class Enumerator
 
     def initialize_with_optional_block(*arg, &block)
       return initialize_without_optional_block(*arg, &nil) unless arg.empty?  # Ruby 1.9 apparently ignores the block if any argument is present
-      initialize_without_optional_block(Generator.new(&block))
+      initialize_without_optional_block(GeneratorBP.new(&block))
     end
     Backports.alias_method_chain self, :initialize, :optional_block
   end

data/lib/backports/1.9.1/hash.rb

@@ -8,7 +8,12 @@ class Hash
 
   # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Hash.html]
   def default_proc=(proc)
-    replace(Hash.new(&Backports.coerce_to(proc, Proc, :to_proc)).merge!(self))
+    if proc == nil # nil accepted in Ruby 2.0
+      self.default = nil
+      self
+    else
+      replace(Hash.new(&Backports.coerce_to(proc, Proc, :to_proc)).merge!(self))
+    end
   end unless method_defined? :default_proc=
 
   # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Hash.html]

data/lib/backports/2.0.0/enumerable.rb

@@ -1,9 +1,12 @@
-module Enumerable
-  def lazy
-    Enumerator::Lazy.new(self){|yielder, *val| yielder.<<(*val)}
-  end unless method_defined? :lazy
-end
+unless Enumerable.method_defined? :lazy
+  module Enumerable
+    def lazy
+      klass = Enumerator::Lazy.send :class_variable_get, :@@lazy_with_no_block # Note: class_variable_get is private in 1.8
+      Enumerator::Lazy.new(klass.new(self, :each, []))
+    end
+  end
 
-class Enumerator
-  require_relative 'enumerator/lazy' unless const_defined? :Lazy
+  class Enumerator
+    require_relative 'enumerator/lazy'
+  end
 end

data/lib/backports/2.0.0/enumerator/lazy.rb

@@ -10,13 +10,16 @@ class Enumerator
 
   class Lazy < Enumerator
     @@done = :__backports_lazy_enumeration_done__   # used internally to bail out of an iteration
-
-    alias_method :non_lazy_cycle, :cycle # cycle must be handled in a tricky way
-    @@cycler = Struct.new(:object, :n)
+    @@lazy_with_no_block = Struct.new(:object, :method, :args) # used internally to create lazy without block
 
     def initialize(obj)
-      return super(obj.object, :non_lazy_cycle, obj.n) if obj.is_a?(@@cycler)
+      if obj.is_a?(@@lazy_with_no_block)
+        @inspect_info = obj
+        return super(@receiver = obj.object, @method = obj.method || :each, * @args = obj.args)
+      end
       raise ArgumentError, "must supply a block" unless block_given?
+      @receiver = obj
+      @method = caller[1][/`([^']*)'/, 1]
       super() do |yielder, *args|
         catch @@done do
           obj.each(*args) do |*x|
@@ -32,6 +35,41 @@ class Enumerator
       self
     end
 
+    def to_enum(method = :each, *args)
+      Lazy.new(@@lazy_with_no_block.new(self, method, args))
+    end
+    alias_method :enum_for, :to_enum
+
+    def inspect
+      suff = ''
+      suff << ":#{@method}" unless @method == :each
+      suff << "(#{@args.inspect[1...-1]})" if @args && !@args.empty?
+      "#<#{self.class}: #{@receiver.inspect}#{suff}>"
+    end
+
+    {
+      :slice_before => //,
+      :with_index => [],
+      :cycle => [],
+      :each_with_object => 42,
+      :each_slice => 42,
+      :each_entry => [],
+      :each_cons => 42,
+    }.each do |method, args|
+      unless [].lazy.send(method, *args).is_a?(Lazy) # Nothing to do if already backported, since it would use to_enum...
+        module_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{method}(*args)                                     # def cycle(*args)
+            return to_enum(:#{method}, *args) unless block_given?  #   return to_enum(:cycle, *args) unless block_given?
+            super                                                  #   super
+          end                                                      # end
+        EOT
+      end
+    end
+
+    def chunk(*)
+      super.lazy
+    end unless [].lazy.chunk{}.is_a?(Lazy)
+
     def map
       raise ArgumentError, "tried to call lazy map without a block" unless block_given?
       Lazy.new(self) do |yielder, *values|
@@ -69,7 +107,7 @@ class Enumerator
           values = values.first unless values.size > 1
           yielder.yield(values) if pattern === values
         end
-      end
+      end.__set_inspect([pattern])
     end
 
     def drop(n)
@@ -81,7 +119,7 @@ class Enumerator
         else
           yielder.yield(*values)
         end
-      end
+      end.__set_inspect([n])
     end
 
     def drop_while
@@ -95,12 +133,11 @@ class Enumerator
     def take(n)
       n = Backports::coerce_to_int(n)
       raise ArgumentError, 'attempt to take negative size' if n < 0
-      return Lazy.new([]){} if n == 0
-      Lazy.new(self) do |yielder, *values|
+      Lazy.new(n == 0 ? [] : self) do |yielder, *values|
         data = yielder.backports_memo ||= {:remain => n}
         yielder.yield(*values)
         throw @@done if (data[:remain] -= 1) == 0
-      end
+      end.__set_inspect([n], self)
     end
 
     def take_while
@@ -125,11 +162,6 @@ class Enumerator
     end
     alias_method :collect_concat, :flat_map
 
-    def cycle(n = nil)
-      return super if block_given?
-      Lazy.new(@@cycler.new(self, n))
-    end
-
     def zip(*args)
       return super if block_given?
       arys = args.map{ |arg| Backports.is_array?(arg) }
@@ -143,6 +175,9 @@ class Enumerator
           data[:iter] += 1
         end
       else
+        args.each do |a|
+          raise TypeError, "wrong argument type #{a.class} (must respond to :each)" unless a.respond_to? :each
+        end
         Lazy.new(self) do |yielder, *values|
           enums = yielder.backports_memo ||= args.map(&:to_enum)
           values = values.first unless values.size > 1
@@ -155,7 +190,14 @@ class Enumerator
           end
           yielder << others.unshift(values)
         end
-      end
+      end.__set_inspect(args)
+    end
+
+    protected
+    def __set_inspect(args, receiver = nil)
+      @args = args
+      @receiver = receiver if receiver
+      self
     end
   end
 end

data/lib/backports/2.0.0/hash.rb

@@ -0,0 +1,16 @@
+class Hash
+  def to_h
+    self
+  end unless method_defined :to_h
+
+  def default_proc_with_nil=(proc)
+    if proc == nil
+      self.default = nil
+      self
+    else
+      self.default_proc_without_nil=(proc)
+    end
+  end if ({}.default_proc = nil rescue true)
+end
+
+Backports.alias_method(ENV, :to_h, :to_hash)

data/lib/backports/2.0.0/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def to_h
+    {}
+  end unless method_defined? :to_h
+end

data/lib/backports/2.0.0/stdlib.rb

@@ -0,0 +1 @@
+Backports::StdLib.extend_relative

data/lib/backports/2.0.0/stdlib/ostruct.rb

@@ -0,0 +1,27 @@
+class OpenStruct
+  def [](name)
+    @table[name.to_sym]
+  end unless method_defined? :[]
+
+  def []=(name, value)
+    modifiable[new_ostruct_member(name)] = value
+  end unless method_defined? :[]=
+
+  def eql?(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table.eql?(other.table)
+  end unless method_defined? :eql?
+
+  def hash
+    @table.hash
+  end unless method_defined? :hash
+
+  def each_pair
+    return to_enum __method__ unless block_given?
+    @table.each_pair{|p| yield p}
+  end unless method_defined? :each_pair
+
+  def to_h
+    @table.dup
+  end unless method_defined? :to_h
+end

data/lib/backports/2.0.0/struct.rb

@@ -0,0 +1,7 @@
+class Struct
+	def to_h
+    Hash[
+      self.class.members.each{|m| [m.to_sym, self[m]]}
+    ]
+  end unless method_defined? :to_h
+end

data/lib/backports/tools.rb

@@ -248,7 +248,7 @@ module Backports
   # Used internally.
   # Safe alias_method that will only alias if the source exists and destination doesn't
   def self.alias_method(mod, new_name, old_name)
-    mod.class_eval do
+    mod.instance_eval do
       alias_method new_name, old_name if method_defined?(old_name) and not method_defined?(new_name)
     end
   end

data/lib/backports/version.rb

@@ -1,3 +1,3 @@
 module Backports
-  VERSION = "2.8.2"
+  VERSION = "3.0.0"
 end

data/test/test_lazy.rb

@@ -0,0 +1,481 @@
+# This is copied & modified from MRI
+require 'test/unit'
+#require_relative 'envutil'
+
+class TestLazyEnumerator < Test::Unit::TestCase
+  class Step
+    include Enumerable
+    attr_reader :current, :args
+
+    def initialize(enum)
+      @enum = enum
+      @current = nil
+      @args = nil
+    end
+
+    def each(*args)
+      @args = args
+      @enum.each {|i| @current = i; yield i}
+    end
+  end
+
+  def test_initialize
+    assert_equal([1, 2, 3], [1, 2, 3].lazy.to_a)
+    assert_equal([1, 2, 3], Enumerator::Lazy.new([1, 2, 3]){|y, v| y << v}.to_a)
+    assert_raise(ArgumentError) { Enumerator::Lazy.new([1, 2, 3]) }
+  end
+
+  ### Backports: Disabled because of Enumerator#each not passing args in MRI < 2.0
+  # def test_each_args
+  #   a = Step.new(1..3)
+  #   assert_equal(1, a.lazy.each(4).first)
+  #   assert_equal([4], a.args)
+  # end
+
+  def test_each_line
+    name = lineno = nil
+    File.open(__FILE__) do |f|
+      f.each("").map do |paragraph|
+        paragraph[/\A\s*(.*)/, 1]
+      end.find do |line|
+        if name = line[/^class\s+(\S+)/, 1]
+          lineno = f.lineno
+          true
+        end
+      end
+    end
+    assert_equal(self.class.name, name)
+    assert_operator(lineno, :>, 2)
+
+    name = lineno = nil
+    File.open(__FILE__) do |f|
+      ### Backports: Modified to avoid bug of Enumerator#each not passing args in MRI < 2.0
+      f.each("").lazy.map do |paragraph| #
+        paragraph[/\A\s*(.*)/, 1]
+      end.find do |line|
+        if name = line[/^class\s+(\S+)/, 1]
+          lineno = f.lineno
+          true
+        end
+      end
+    end
+    assert_equal(self.class.name, name)
+    assert_equal(2, lineno)
+  end
+
+  def test_select
+    a = Step.new(1..6)
+    assert_equal(4, a.select {|x| x > 3}.first)
+    assert_equal(6, a.current)
+    assert_equal(4, a.lazy.select {|x| x > 3}.first)
+    assert_equal(4, a.current)
+
+    a = Step.new(['word', nil, 1])
+    assert_raise(TypeError) {a.select {|x| "x"+x}.first}
+    assert_equal(nil, a.current)
+    assert_equal("word", a.lazy.select {|x| "x"+x}.first)
+    assert_equal("word", a.current)
+  end
+
+  def test_select_multiple_values
+    e = Enumerator.new { |yielder|
+      for i in 1..5
+        yielder.yield(i, i.to_s)
+      end
+    }
+    assert_equal([[2, "2"], [4, "4"]],
+                 e.select {|x| x[0] % 2 == 0})
+    assert_equal([[2, "2"], [4, "4"]],
+                 e.lazy.select {|x| x[0] % 2 == 0}.force)
+  end
+
+  def test_map
+    a = Step.new(1..3)
+    assert_equal(2, a.map {|x| x * 2}.first)
+    assert_equal(3, a.current)
+    assert_equal(2, a.lazy.map {|x| x * 2}.first)
+    assert_equal(1, a.current)
+  end
+
+  def test_flat_map
+    a = Step.new(1..3)
+    assert_equal(2, a.flat_map {|x| [x * 2]}.first)
+    assert_equal(3, a.current)
+    assert_equal(2, a.lazy.flat_map {|x| [x * 2]}.first)
+    assert_equal(1, a.current)
+  end
+
+  def test_flat_map_nested
+    a = Step.new(1..3)
+    assert_equal([1, "a"],
+                 a.flat_map {|x| ("a".."c").map {|y| [x, y]}}.first)
+    assert_equal(3, a.current)
+    assert_equal([1, "a"],
+                 a.lazy.flat_map {|x| ("a".."c").lazy.map {|y| [x, y]}}.first)
+    assert_equal(1, a.current)
+  end
+
+  def test_flat_map_to_ary
+    to_ary = Class.new {
+      def initialize(value)
+        @value = value
+      end
+
+      def to_ary
+        [:to_ary, @value]
+      end
+    }
+    assert_equal([:to_ary, 1, :to_ary, 2, :to_ary, 3],
+                 [1, 2, 3].flat_map {|x| to_ary.new(x)})
+    assert_equal([:to_ary, 1, :to_ary, 2, :to_ary, 3],
+                 [1, 2, 3].lazy.flat_map {|x| to_ary.new(x)}.force)
+  end
+
+  def test_flat_map_non_array
+    assert_equal(["1", "2", "3"], [1, 2, 3].flat_map {|x| x.to_s})
+    assert_equal(["1", "2", "3"], [1, 2, 3].lazy.flat_map {|x| x.to_s}.force)
+  end
+
+  def test_flat_map_hash
+    assert_equal([{?a=>97}, {?b=>98}, {?c=>99}], [?a, ?b, ?c].flat_map {|x| {x=>x.ord}})
+    assert_equal([{?a=>97}, {?b=>98}, {?c=>99}], [?a, ?b, ?c].lazy.flat_map {|x| {x=>x.ord}}.force)
+  end
+
+  def test_reject
+    a = Step.new(1..6)
+    assert_equal(4, a.reject {|x| x < 4}.first)
+    assert_equal(6, a.current)
+    assert_equal(4, a.lazy.reject {|x| x < 4}.first)
+    assert_equal(4, a.current)
+
+    a = Step.new(['word', nil, 1])
+    assert_equal(nil, a.reject {|x| x}.first)
+    assert_equal(1, a.current)
+    assert_equal(nil, a.lazy.reject {|x| x}.first)
+    assert_equal(nil, a.current)
+  end
+
+  def test_reject_multiple_values
+    e = Enumerator.new { |yielder|
+      for i in 1..5
+        yielder.yield(i, i.to_s)
+      end
+    }
+    assert_equal([[2, "2"], [4, "4"]],
+                 e.reject {|x| x[0] % 2 != 0})
+    assert_equal([[2, "2"], [4, "4"]],
+                 e.lazy.reject {|x| x[0] % 2 != 0}.force)
+  end
+
+  def test_grep
+    a = Step.new('a'..'f')
+    assert_equal('c', a.grep(/c/).first)
+    assert_equal('f', a.current)
+    assert_equal('c', a.lazy.grep(/c/).first)
+    assert_equal('c', a.current)
+    assert_equal(%w[a e], a.grep(proc {|x| /[aeiou]/ =~ x}))
+    assert_equal(%w[a e], a.lazy.grep(proc {|x| /[aeiou]/ =~ x}).to_a)
+  end
+
+  def test_grep_with_block
+    a = Step.new('a'..'f')
+    assert_equal('C', a.grep(/c/) {|i| i.upcase}.first)
+    assert_equal('C', a.lazy.grep(/c/) {|i| i.upcase}.first)
+  end
+
+  def test_grep_multiple_values
+    e = Enumerator.new { |yielder|
+      3.times { |i|
+        yielder.yield(i, i.to_s)
+      }
+    }
+    assert_equal([[2, "2"]], e.grep(proc {|x| x == [2, "2"]}))
+    assert_equal([[2, "2"]], e.lazy.grep(proc {|x| x == [2, "2"]}).force)
+    assert_equal(["22"],
+                 e.lazy.grep(proc {|x| x == [2, "2"]}, &:join).force)
+  end
+
+  def test_zip
+    a = Step.new(1..3)
+    assert_equal([1, "a"], a.zip("a".."c").first)
+    assert_equal(3, a.current)
+    assert_equal([1, "a"], a.lazy.zip("a".."c").first)
+    assert_equal(1, a.current)
+  end
+
+  def test_zip_short_arg
+    a = Step.new(1..5)
+    assert_equal([5, nil], a.zip("a".."c").last)
+    assert_equal([5, nil], a.lazy.zip("a".."c").force.last)
+  end
+
+  def test_zip_without_arg
+    a = Step.new(1..3)
+    assert_equal([1], a.zip.first)
+    assert_equal(3, a.current)
+    assert_equal([1], a.lazy.zip.first)
+    assert_equal(1, a.current)
+  end
+
+  def test_zip_bad_arg
+    a = Step.new(1..3)
+    assert_raise(TypeError){ a.lazy.zip(42) }
+  end
+
+  def test_zip_with_block
+    # zip should be eager when a block is given
+    a = Step.new(1..3)
+    ary = []
+    assert_equal(nil, a.lazy.zip("a".."c") {|x, y| ary << [x, y]})
+    assert_equal(a.zip("a".."c"), ary)
+    assert_equal(3, a.current)
+  end
+
+  def test_take
+    a = Step.new(1..10)
+    assert_equal(1, a.take(5).first)
+    assert_equal(5, a.current)
+    assert_equal(1, a.lazy.take(5).first)
+    assert_equal(1, a.current)
+    assert_equal((1..5).to_a, a.lazy.take(5).force)
+    assert_equal(5, a.current)
+    a = Step.new(1..10)
+    assert_equal([], a.lazy.take(0).force)
+    assert_equal(nil, a.current)
+  end
+
+  def test_take_recycle
+    bug6428 = '[ruby-dev:45634]'
+    a = Step.new(1..10)
+    take5 = a.lazy.take(5)
+    assert_equal((1..5).to_a, take5.force, bug6428)
+    assert_equal((1..5).to_a, take5.force, bug6428)
+  end
+
+  def test_take_nested
+    bug7696 = '[ruby-core:51470]'
+    a = Step.new(1..10)
+    take5 = a.lazy.take(5)
+    assert_equal([*(1..5)]*5, take5.flat_map{take5}.force, bug7696)
+  end
+
+  def test_drop_while_nested
+    bug7696 = '[ruby-core:51470]'
+    a = Step.new(1..10)
+    drop5 = a.lazy.drop_while{|x| x < 6}
+    assert_equal([*(6..10)]*5, drop5.flat_map{drop5}.force, bug7696)
+  end
+
+  def test_drop_nested
+    bug7696 = '[ruby-core:51470]'
+    a = Step.new(1..10)
+    drop5 = a.lazy.drop(5)
+    assert_equal([*(6..10)]*5, drop5.flat_map{drop5}.force, bug7696)
+  end
+
+  def test_zip_nested
+    bug7696 = '[ruby-core:51470]'
+    enum = ('a'..'z').each
+    enum.next
+    zip = (1..3).lazy.zip(enum, enum)
+    assert_equal([[1, 'a', 'a'], [2, 'b', 'b'], [3, 'c', 'c']]*3, zip.flat_map{zip}.force, bug7696)
+  end
+
+  def test_zip_lazy_on_args
+    zip = Step.new(1..2).lazy.zip(42..Float::INFINITY)
+    assert_equal [[1, 42], [2, 43]], zip.force
+  end
+
+  def test_zip_efficient_on_array_args
+    ary = [42, :foo]
+    [:to_enum, :enum_for, :lazy, :each].each do |forbid|
+      ary.define_singleton_method(forbid){ fail "#{forbid} was called"}
+    end
+    zip = Step.new(1..2).lazy.zip(ary)
+    assert_equal [[1, 42], [2, :foo]], zip.force
+  end
+
+  def test_take_rewound
+    bug7696 = '[ruby-core:51470]'
+    e=(1..42).lazy.take(2)
+    assert_equal 1, e.next
+    assert_equal 2, e.next
+    e.rewind
+    assert_equal 1, e.next
+    assert_equal 2, e.next
+  end
+
+  def test_take_while
+    a = Step.new(1..10)
+    assert_equal(1, a.take_while {|i| i < 5}.first)
+    assert_equal(5, a.current)
+    assert_equal(1, a.lazy.take_while {|i| i < 5}.first)
+    assert_equal(1, a.current)
+    assert_equal((1..4).to_a, a.lazy.take_while {|i| i < 5}.to_a)
+  end
+
+  def test_drop
+    a = Step.new(1..10)
+    assert_equal(6, a.drop(5).first)
+    assert_equal(10, a.current)
+    assert_equal(6, a.lazy.drop(5).first)
+    assert_equal(6, a.current)
+    assert_equal((6..10).to_a, a.lazy.drop(5).to_a)
+  end
+
+  def test_drop_while
+    a = Step.new(1..10)
+    assert_equal(5, a.drop_while {|i| i < 5}.first)
+    assert_equal(10, a.current)
+    assert_equal(5, a.lazy.drop_while {|i| i < 5}.first)
+    assert_equal(5, a.current)
+    assert_equal((5..10).to_a, a.lazy.drop_while {|i| i < 5}.to_a)
+  end
+
+  def test_drop_and_take
+    assert_equal([4, 5], (1..Float::INFINITY).lazy.drop(3).take(2).to_a)
+  end
+
+  def test_cycle
+    a = Step.new(1..3)
+    assert_equal("1", a.cycle(2).map(&:to_s).first)
+    assert_equal(3, a.current)
+    assert_equal("1", a.lazy.cycle(2).map(&:to_s).first)
+    assert_equal(1, a.current)
+  end
+
+  def test_cycle_with_block
+    # cycle should be eager when a block is given
+    a = Step.new(1..3)
+    ary = []
+    assert_equal(nil, a.lazy.cycle(2) {|i| ary << i})
+    assert_equal(a.cycle(2).to_a, ary)
+    assert_equal(3, a.current)
+  end
+
+  def test_cycle_chain
+    a = 1..3
+    assert_equal([1,2,3,1,2,3,1,2,3,1], a.lazy.cycle.take(10).force)
+    assert_equal([2,2,2,2,2,2,2,2,2,2], a.lazy.cycle.select {|x| x == 2}.take(10).force)
+    assert_equal([2,2,2,2,2,2,2,2,2,2], a.lazy.select {|x| x == 2}.cycle.take(10).force)
+  end
+
+  def test_force
+    assert_equal([1, 2, 3], (1..Float::INFINITY).lazy.take(3).force)
+  end
+
+  def test_inspect
+    assert_equal("#<Enumerator::Lazy: 1..10>", (1..10).lazy.inspect)
+    assert_equal('#<Enumerator::Lazy: #<Enumerator: "foo":each_char>>',
+                 "foo".each_char.lazy.inspect)
+    assert_equal("#<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:map>",
+                 (1..10).lazy.map {}.inspect)
+    assert_equal("#<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:take(0)>",
+                 (1..10).lazy.take(0).inspect)
+    assert_equal("#<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:take(3)>",
+                 (1..10).lazy.take(3).inspect)
+    assert_equal('#<Enumerator::Lazy: #<Enumerator::Lazy: "a".."c">:grep(/b/)>',
+                 ("a".."c").lazy.grep(/b/).inspect)
+    assert_equal("#<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:cycle(3)>",
+                 (1..10).lazy.cycle(3).inspect)
+    assert_equal("#<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:cycle>",
+                 (1..10).lazy.cycle.inspect)
+    assert_equal("#<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:cycle(3)>",
+                 (1..10).lazy.cycle(3).inspect)
+    l = (1..10).lazy.map {}.collect {}.flat_map {}.collect_concat {}.select {}.find_all {}.reject {}.grep(1).zip(?a..?c).take(10).take_while {}.drop(3).drop_while {}.cycle(3)
+    ### Backport: Modified because I don't think the actual name we were called under in case of aliases is important enough to care
+    assert_equal(<<EOS.chomp, l.inspect)
+#<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator::Lazy: 1..10>:map>:map>:flat_map>:flat_map>:select>:select>:reject>:grep(1)>:zip("a".."c")>:take(10)>:take_while>:drop(3)>:drop_while>:cycle(3)>
+EOS
+  end
+
+  def test_lazy_to_enum
+    lazy = [1, 2, 3].lazy
+    def lazy.foo(*args)
+      yield args
+      yield args
+    end
+    enum = lazy.to_enum(:foo, :hello, :world)
+    assert_equal Enumerator::Lazy, enum.class
+    # assert_equal nil, enum.size  ### Backport: see below
+    assert_equal [[:hello, :world], [:hello, :world]], enum.to_a
+
+    assert_equal [1, 2, 3], lazy.to_enum.to_a
+  end
+
+  ### Backport: way too much work to shim #size
+  # def test_size
+  #   lazy = [1, 2, 3].lazy
+  #   assert_equal 3, lazy.size
+  #   assert_equal 42, Enumerator::Lazy.new([],->{42}){}.size
+  #   assert_equal 42, Enumerator::Lazy.new([],42){}.size
+  #   assert_equal 42, Enumerator::Lazy.new([],42){}.lazy.size
+  #   assert_equal 42, lazy.to_enum{ 42 }.size
+
+  #   [:map, :collect].each do |m|
+  #     assert_equal 3, lazy.send(m){}.size
+  #   end
+  #   assert_equal 3, lazy.zip([4]).size
+  #   [:flat_map, :collect_concat, :select, :find_all, :reject, :take_while, :drop_while].each do |m|
+  #     assert_equal nil, lazy.send(m){}.size
+  #   end
+  #   assert_equal nil, lazy.grep(//).size
+
+  #   assert_equal 2, lazy.take(2).size
+  #   assert_equal 3, lazy.take(4).size
+  #   assert_equal 4, loop.lazy.take(4).size
+  #   assert_equal nil, lazy.select{}.take(4).size
+
+  #   assert_equal 1, lazy.drop(2).size
+  #   assert_equal 0, lazy.drop(4).size
+  #   assert_equal Float::INFINITY, loop.lazy.drop(4).size
+  #   assert_equal nil, lazy.select{}.drop(4).size
+
+  #   assert_equal 0, lazy.cycle(0).size
+  #   assert_equal 6, lazy.cycle(2).size
+  #   assert_equal 3 << 80, 4.times.inject(lazy){|enum| enum.cycle(1 << 20)}.size
+  #   assert_equal Float::INFINITY, lazy.cycle.size
+  #   assert_equal Float::INFINITY, loop.lazy.cycle(4).size
+  #   assert_equal Float::INFINITY, loop.lazy.cycle.size
+  #   assert_equal nil, lazy.select{}.cycle(4).size
+  #   assert_equal nil, lazy.select{}.cycle.size
+  # end
+
+  # def test_map_zip
+  #   bug7507 = '[ruby-core:50545]'
+  #   assert_ruby_status(["-e", "GC.stress = true", "-e", "(1..10).lazy.map{}.zip(){}"], bug7507)
+  #   assert_ruby_status(["-e", "GC.stress = true", "-e", "(1..10).lazy.map{}.zip().to_a"], bug7507)
+  # end
+
+  def test_require_block
+    [:select, :reject, :drop_while, :take_while, :map, :flat_map].each do |method|
+      assert_raise(ArgumentError){ [].lazy.send(method) }
+    end
+  end
+
+  def test_laziness_conservation
+    bug7507 = '[ruby-core:51510]'
+    {
+      :slice_before => //,
+      :with_index => [],
+      :cycle => [],
+      :each_with_object => 42,
+      :each_slice => 42,
+      :each_entry => [],
+      :each_cons => 42,
+    }.each do |method, arg|
+      assert_equal Enumerator::Lazy, [].lazy.send(method, *arg).class, bug7507
+    end
+    assert_equal Enumerator::Lazy, [].lazy.chunk{}.class, bug7507
+  end
+
+  ### Backport: assert_warning not defined, we're ok anyways
+  # def test_no_warnings
+  #   le = (1..3).lazy
+  #   assert_warning("") {le.zip([4,5,6]).force}
+  #   assert_warning("") {le.zip(4..6).force}
+  #   assert_warning("") {le.take(1).force}
+  #   assert_warning("") {le.drop(1).force}
+  #   assert_warning("") {le.drop_while{false}.force}
+  # end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backports
 version: !ruby/object:Gem::Version
-  version: 2.8.2
+  version: 3.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-03 00:00:00.000000000 Z
+date: 2013-02-25 00:00:00.000000000 Z
 dependencies: []
 description: Essential backports that enable some of the really nice features of ruby
   1.8.7, ruby 1.9 and rails from ruby 1.8.6 and earlier.
@@ -105,7 +105,12 @@ files:
 - lib/backports/2.0.0/array.rb
 - lib/backports/2.0.0/enumerable.rb
 - lib/backports/2.0.0/enumerator/lazy.rb
+- lib/backports/2.0.0/hash.rb
+- lib/backports/2.0.0/nil_class.rb
 - lib/backports/2.0.0/range.rb
+- lib/backports/2.0.0/stdlib.rb
+- lib/backports/2.0.0/stdlib/ostruct.rb
+- lib/backports/2.0.0/struct.rb
 - lib/backports/2.0.rb
 - lib/backports/basic_object.rb
 - lib/backports/force/array_map.rb
@@ -125,6 +130,7 @@ files:
 - test/README
 - test/std_lib_loading_test.rb
 - test/test_helper.rb
+- test/test_lazy.rb
 - test/test_socket_interaction.rb
 homepage: http://github.com/marcandre/backports
 licenses: []
@@ -154,5 +160,6 @@ test_files:
 - test/README
 - test/std_lib_loading_test.rb
 - test/test_helper.rb
+- test/test_lazy.rb
 - test/test_socket_interaction.rb
 has_rdoc: