enumerable_lz 0.1.0

data/ChangeLog

@@ -0,0 +1,4 @@
+== 0.1.0 / 2011-01-23
+
+* 1st release
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 GOTOH Shunsuke (@antimon2)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# enumerable_lz
+
+'enumerable_lz' provides filter and transformation methods in `Enumerable` module.
+Also it provides lazy equivalents of some methods in `Enumerable`.
+
+
+## Fundamental Usage
+
+When require 'enumerable_lz', these lazy methods are provided:
+
+* `Enumerable#filter`
+* `Enumerable#filter_with_initproc`
+* `Enumerable#transform`
+
+For example (in Ruby 1.9.x):
+
+    require 'enumerable_lz'
+    require 'prime'
+    
+    (1..Float::INFINITY).transform{|n|n**2+1}.filter{|m|m.prime?}.take(100)
+    # => [2, 5, ... , 682277, 739601] for a few msec.
+
+
+## Expanded Usage
+
+When require 'enumerable_lz/enumerable_ex', some lazy methods equivalents to original `Enumerable` method with suffix '_lz' are provided:
+
+* `Enumerable#select_lz`
+* `Enumerable#find_all_lz`
+* `Enumerable#reject_lz`
+* `Enumerable#grep_lz`
+* `Enumerable#map_lz`
+* `Enumerable#collect_lz`
+* `Enumerable#drop_lz`
+* `Enumerable#drop_while_lz`
+* `Enumerable#take_lz`
+* `Enumerable#take_while_lz`
+
+
+For example (in Ruby 1.9.x):
+
+    require 'enumerable_lz'
+    require 'enumerable_lz/enumerable_ex'
+    require 'prime'
+    
+    (1..Float::INFINITY).map_lz{|n|n**2+1}.select_lz{|m|m.prime?}.take_lz(100).to_a
+    # => [2, 5, ... , 682277, 739601] for a few msec.
+
+These expanded methods are inplemented with fundamental filter and transformation methods.
+
+
+## Supported Rubies
+
+* Ruby 1.9.x (testing 1.9.2-p0, 1.9.2 p-136)
+* Ruby 1.8.7 (testing 1.8.7-p330)
+* JRuby 1.5.x (testing 1.5.6)
+* MacRuby 0.8
+
+## Installation
+
+    gem install enumerable_lz
+
+or
+
+    gem install antimon2-enumerable_lz
+
+
+## License
+
+The MIT License  
+Copyright (c) 2011 GOTOH Shunsuke (@antimon2)
+
+Please see [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new

data/lib/enumerable_lz.rb

@@ -0,0 +1,18 @@
+if RUBY_VERSION > "1.8.7"
+  if RUBY_DESCRIPTION !~ /^macruby/i
+    require File.dirname(__FILE__)+'/enumerable_lz/filter'
+    require File.dirname(__FILE__)+'/enumerable_lz/transform'
+  else
+    require File.dirname(__FILE__)+'/enumerable_lz/filter_mrb'
+    require File.dirname(__FILE__)+'/enumerable_lz/transform_mrb'
+  end
+else
+  require File.dirname(__FILE__)+'/enumerable_lz/filter_18'
+  require File.dirname(__FILE__)+'/enumerable_lz/transform_18'
+end
+
+module Enumerable
+  module EnumerableLz
+    VERSION = "0.1.0"
+  end
+end

data/lib/enumerable_lz/enumerable_ex.rb

@@ -0,0 +1,55 @@
+require File.expand_path('..', __FILE__)
+
+module Enumerable
+  def select_lz &block
+    filter &block
+  end
+
+  alias :find_all_lz :select_lz
+
+  def reject_lz &block
+    filter {|e|!block.call(e)}
+  end
+
+  def grep_lz pattern, &block
+    enum = filter pattern
+    block_given? ? enum.transform(&block) : enum
+  end
+
+  alias :map_lz :transform
+  alias :collect_lz :map_lz
+
+  def drop_lz n
+    raise ArgumentError, "attempt to take negative size" if n < 0
+    # each_with_index.filter{|el,idx|idx >= n}.transform{|el,idx|el}
+    cnt = 0
+    filter_with_initproc(Proc.new{cnt=0}) {|el| (cnt+=1) > n}
+  end
+
+  def drop_while_lz &block
+    return self if !block_given?
+    flg = false
+    filter_with_initproc(Proc.new{flg=false}) {|el|flg || (!block.call(el) ? flg = true : false)}
+  end
+
+  def take_lz n
+    raise ArgumentError, "attempt to take negative size" if n < 0
+    # each_with_index.filter{|el,idx|throw :do_break if idx >= n;true}.transform{|el,idx|el}
+    cnt = 0
+    filter_with_initproc(Proc.new{cnt=0}) {|el| throw :do_break if (cnt+=1) > n;true}
+  end
+
+  def take_while_lz &block
+    return self if !block_given?
+    filter {|el|throw :do_break unless block.call(el);true}
+  end
+
+#  def zip_lz *lists
+#    enums = lists.map{|list|list.each rescue [].each}
+#    Enumerator.new do |y|
+#      self.each do |el|
+#        y << enums.each_with_object([el]){|enum, a|a << (enum.next rescue nil)}
+#      end
+#    end
+#  end
+end

data/lib/enumerable_lz/filter.rb

@@ -0,0 +1,67 @@
+# for Ruby1.9.x except for MacRuby
+module Enumerable
+  def filter pattern = nil, &block
+    Filter.new self, pattern||block
+  end
+
+  def filter_with_initproc init_proc, pattern = nil, &block
+    Filter.new self, init_proc, pattern||block
+  end
+
+  class Filter < Enumerator
+    def initialize obj, *args
+      the_filter = args.shift
+      init_block, the_filter = [the_filter, args.shift] unless args.empty?
+      @org_enum = obj
+      @init_block = init_block unless init_block.nil?
+      super() do |y|
+        @init_block.call unless @init_block.nil?
+        catch :do_break do
+          @org_enum.each do |*el|
+            y.yield *el if matches_filter? *el
+          end
+        end
+      end
+      filter! the_filter if the_filter
+    end
+
+    def filter! pattern=nil, &block
+      @filter||=[]
+      if pattern.is_a? Array
+        @filter.push(*pattern)
+      else
+        @filter<<(pattern || block)
+      end
+      self
+    end
+
+    #[override]
+    def filter pattern=nil, &block
+      return super unless @init_block.nil?
+      # clone.filter! pattern, &block
+      patterns = @filter.nil? ? [] : @filter.clone
+      if pattern.is_a? Array
+        patterns.push(*pattern)
+      else
+        patterns<<(pattern || block)
+      end
+      Filter.new @org_enum, patterns
+    end
+
+    private
+    def matches_filter? obj, *others
+      return true if @filter.nil?
+      args = [obj, *others]
+      @filter.all? do |filter|
+        case filter
+        when nil
+          true
+        when Proc
+          filter[*args]
+        else
+          filter===obj
+        end
+      end
+    end
+  end
+end

data/lib/enumerable_lz/filter_18.rb

@@ -0,0 +1,71 @@
+# for Ruby1.8.7
+module Enumerable
+  def filter pattern = nil, &block
+    Filter.new self, pattern||block
+  end
+
+  def filter_with_initproc init_proc, pattern = nil, &block
+    Filter.new self, init_proc, pattern||block
+  end
+
+  class Filter < Enumerator
+    require 'generator'
+    def initialize obj, *args
+      the_filter = args.shift
+      init_block, the_filter = [the_filter, args.shift] unless args.empty?
+      filter! the_filter if the_filter
+      @org_enum = obj
+      @init_block = init_block unless init_block.nil?
+    end
+
+    def each &block
+      return self unless block_given?
+      catch :do_break do
+        @init_block.call unless @init_block.nil?
+        @org_enum.each do |*el|
+          block.call(*el) if matches_filter? *el
+        end
+      end
+      self
+    end
+
+    def filter! pattern=nil, &block
+      @filter||=[]
+      if pattern.is_a? Array
+        @filter.push(*pattern)
+      else
+        @filter<<(pattern || block)
+      end
+      self
+    end
+
+    #[override]
+    def filter pattern=nil, &block
+      return super unless @init_block.nil?
+      # clone.filter! pattern, &block
+      patterns = @filter.nil? ? [] : @filter.clone
+      if pattern.is_a? Array
+        patterns.push(*pattern)
+      else
+        patterns << (pattern || block)
+      end
+      Filter.new @org_enum, patterns
+    end
+
+    private
+    def matches_filter? obj, *others
+      return true if @filter.nil?
+      args = [obj, *others]
+      @filter.all? do |filter|
+        case filter
+        when nil
+          true
+        when Proc
+          filter[*args]
+        else
+          filter===obj
+        end
+      end
+    end
+  end
+end

data/lib/enumerable_lz/filter_mrb.rb

@@ -0,0 +1,72 @@
+# for MacRuby
+module Enumerable
+  def filter pattern = nil, &block
+    Filter.new self, pattern||block
+  end
+
+  def filter_with_initproc init_proc, pattern = nil, &block
+    Filter.new self, init_proc, pattern||block
+  end
+
+  class Filter < Enumerator
+    def initialize obj, *args
+      the_filter = args.shift
+      init_block, the_filter = [the_filter, args.shift] unless args.empty?
+      @org_enum = obj
+      @init_block = init_block unless init_block.nil?
+      outer = self
+      super Class.new {
+        define_method :each do
+          return outer unless block_given?
+          init_block.call unless init_block.nil?
+          catch :do_break do
+            obj.each do |*el|
+              yield *el if outer.__send__(:matches_filter?, *el)
+            end
+          end
+          outer
+        end
+      }.new
+      filter! the_filter if the_filter
+    end
+
+    def filter! pattern=nil, &block
+      @filter||=[]
+      if pattern.is_a? Array
+        @filter.push(*pattern)
+      else
+        @filter<<(pattern || block)
+      end
+      self
+    end
+
+    #[override]
+    def filter pattern=nil, &block
+      # clone.filter! pattern, &block
+      patterns = @filter.nil? ? [] : @filter.clone
+      if pattern.is_a? Array
+        patterns.push(*pattern)
+      else
+        patterns<<(pattern || block)
+      end
+      return Filter.new @org_enum, @init_block, patterns unless @init_block.nil?
+      Filter.new @org_enum, patterns
+    end
+
+    private
+    def matches_filter? obj, *others
+      return true if @filter.nil?
+      args = [obj, *others]
+      @filter.all? do |filter|
+        case filter
+        when nil
+          true
+        when Proc
+          filter[*args]
+        else
+          filter===obj
+        end
+      end
+    end
+  end
+end

data/lib/enumerable_lz/transform.rb

@@ -0,0 +1,49 @@
+# for Ruby1.9.x except for MacRuby
+module Enumerable
+  def transform &block
+    Transform.new self, &block
+  end
+
+  class Transform < Enumerator
+    def initialize obj, &transformer
+      @org_enum = obj
+      super() do |y|
+        obj.each do |*el|
+          y << apply_transform(*el)
+        end
+      end
+      transform! &transformer if block_given?
+    end
+
+    def transform! &block
+      @transformer||=[]
+      @transformer << block if block_given?
+      self
+    end
+
+    #[override]
+    def transform &block
+      # clone.transform! &block
+      cp = Transform.new @org_enum
+      @transformer.each do |org_block|
+        cp.transform! &org_block
+      end unless @transformer.nil?
+      cp.transform! &block
+    end
+
+#    def clone
+#      cp = super
+#      cp.instance_eval { @transformer = @transformer.nil? ? [] : @transformer.clone }
+#      cp
+#    end
+
+    private
+    def apply_transform *args
+      result = args
+      @transformer.each do |transformer|
+        result = transformer[*result] unless transformer.nil?
+      end unless @transformer.nil?
+      result
+    end
+  end
+end

data/lib/enumerable_lz/transform_18.rb

@@ -0,0 +1,46 @@
+# for Ruby1.8.7
+module Enumerable
+  def transform &block
+    Transform.new self, &block
+  end
+
+  class Transform < Enumerator
+    def initialize obj, &transformer
+      @org_enum = obj
+      transform! &transformer if block_given?
+    end
+
+    def each &block
+      return self unless block_given?
+      @org_enum.each do |*el|
+        block.call apply_transform(*el)
+      end
+      self
+    end
+
+    def transform! &block
+      @transformer||=[]
+      @transformer << block if block_given?
+      self
+    end
+
+    #[override]
+    def transform &block
+      # clone.transform! &block
+      cp = Transform.new @org_enum
+      @transformer.each do |org_block|
+        cp.transform! &org_block
+      end unless @transformer.nil?
+      cp.transform! &block
+    end
+
+    private
+    def apply_transform *args
+      result = args
+      @transformer.each do |transformer|
+        result = transformer[*result] unless transformer.nil?
+      end unless @transformer.nil?
+      result
+    end
+  end
+end

data/lib/enumerable_lz/transform_mrb.rb

@@ -0,0 +1,47 @@
+# for MacRuby
+module Enumerable
+  def transform &block
+    Transform.new self, &block
+  end
+
+  class Transform < Enumerator
+    def initialize obj, &transformer
+      @org_enum = obj
+      outer = self
+      super Class.new {
+        define_method :each do
+          return outer unless block_given?
+          obj.each do |*el|
+            yield outer.__send__(:apply_transform, *el)
+          end
+        end
+      }.new
+      transform! &transformer if block_given?
+    end
+
+    def transform! &block
+      @transformer||=[]
+      @transformer << block if block_given?
+      self
+    end
+
+    #[override]
+    def transform &block
+      # clone.transform! &block
+      cp = Transform.new @org_enum
+      @transformer.each do |org_block|
+        cp.transform! &org_block
+      end unless @transformer.nil?
+      cp.transform! &block
+    end
+
+    private
+    def apply_transform *args
+      result = args
+      @transformer.each do |transformer|
+        result = transformer[*result] unless transformer.nil?
+      end unless @transformer.nil?
+      result
+    end
+  end
+end

data/test/test_enumerable_ex.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require 'enumerable_lz'
+require 'enumerable_lz/enumerable_ex'
+
+class EnumerableExTest < Test::Unit::TestCase
+  def test_basic
+    cnt=0
+    (1..1000000).map_lz{|n|(cnt=n)**2}.take_while{|n|n<10000}
+    assert(cnt<1000000)
+#    cnt=0
+#    (0..1000000).map{|n|(cnt=n)**2}.take_while{|n|n<10000}
+#    assert_equal(1000001, cnt)
+  end
+
+  def setup
+    @arr_str = %w[Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum]
+  end
+
+  def test_select_lz
+    enum = @arr_str.select_lz{|letters|letters.size==5}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.select{|letters|letters.size==5}, enum.to_a)
+  end
+
+  def test_find_all_lz
+    enum = @arr_str.find_all_lz{|letters|letters.size==4}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.find_all{|letters|letters.size==4}, enum.to_a)
+  end
+
+  def test_reject_lz
+    enum = @arr_str.reject_lz{|letters|letters.size>5}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.reject{|letters|letters.size>5}, enum.to_a)
+  end
+
+  def test_grep_lz
+    enum = @arr_str.grep_lz(/^[A-Z]/)
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.grep(/^[A-Z]/), enum.to_a)
+  end
+
+  def test_grep_lz_block
+    enum = @arr_str.grep_lz(/^[A-Z]/){|c|c.swapcase}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.grep(/^[A-Z]/){|c|c.swapcase}, enum.to_a)
+  end
+
+  def test_map_lz
+    enum = @arr_str.map_lz{|c|c.swapcase}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.map{|c|c.swapcase}, enum.to_a)
+  end
+
+  def test_collect_lz
+    enum = @arr_str.collect_lz{|c|c.downcase}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.collect{|c|c.downcase}, enum.to_a)
+  end
+
+  def test_drop_lz
+    enum = @arr_str.drop_lz(10)
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.drop(10), enum.to_a)
+  end
+
+  def test_drop_while_lz
+    enum = @arr_str.drop_while_lz{|letters|letters.size < 6}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.drop_while{|letters|letters.size < 6}, enum.to_a)
+  end
+
+  def test_take_lz
+    enum = @arr_str.take_lz(10)
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.take(10), enum.to_a)
+  end
+
+  def test_take_while_lz
+    enum = @arr_str.take_while_lz{|letters|letters.size < 6}
+    assert_kind_of(Enumerable, enum)
+    assert_equal(@arr_str.take_while{|letters|letters.size < 6}, enum.to_a)
+  end
+end

data/test/test_filter.rb

@@ -0,0 +1,125 @@
+require 'test/unit'
+require 'enumerable_lz'
+
+class FilterTest < Test::Unit::TestCase
+  def test_instance
+    enum = Enumerable::Filter.new []
+    assert_not_nil(enum)
+    assert_kind_of(Enumerable, enum)
+  end
+
+  def test_filter_array
+    array = %w[Yes I have a number]
+    enum = array.filter{|letters|letters.size > 1}
+    assert_instance_of(Enumerable::Filter, enum)
+    assert_equal(%w[Yes have number], enum.to_a)
+  end
+
+  def test_pattern_filtering_1
+    range = "a"..."aaa"
+    enum = range.filter(/[aeiou]{2}/)
+    assert_equal(%w[aa ae ai ao au ea ee ei eo eu ia ie ii io iu oa oe oi oo ou ua ue ui uo uu], enum.to_a)
+  end
+
+  def test_pattern_filtering_2_1
+    array = [123, "abc", Math::PI, %q[q], nil]
+    enum1 = array.filter(String)
+    assert_equal(["abc", "q"], enum1.to_a)
+  end
+
+  def test_pattern_filtering_2_2
+    array = [123, "abc", Math::PI, %q[q], nil]
+    enum2 = array.filter(Numeric)
+    assert_equal([123, Math::PI], enum2.to_a)
+  end
+
+  def test_pattern_filtering_2_3
+    array = [123, "abc", Math::PI, %q[q], nil]
+    enum3 = array.filter(1..100)
+    assert_equal([Math::PI], enum3.to_a)
+  end
+
+  def test_multi_filter_1
+    range = -10..10
+    pr1 = lambda{|n|n>2}
+    pr2 = lambda{|n|n**2<10}
+    enum1 = range.filter(&pr1).filter(&pr2)
+    assert_equal([3], enum1.to_a)
+  end
+
+  def test_multi_filter_2
+    range = -10..10
+    pr1 = lambda{|n|n>2}
+    pr2 = lambda{|n|n**2<10}
+    enum2 = range.filter(&pr2).filter(&pr1)
+    assert_equal([3], enum2.to_a)
+  end
+
+  def test_multi_filter_3
+    range = -10..10
+    pr1 = lambda{|n|n>2}
+    pr2 = lambda{|n|n**2<10}
+    enum2 = range.filter([pr1, pr2])
+    assert_equal([3], enum2.to_a)
+  end
+
+  def test_multi_filter_4
+    range = -10..10
+    pr1 = lambda{|n|n>2}
+    pr2 = lambda{|n|n**2<10}
+    enum1 = range.filter(&pr1)
+    arr1 = enum1.to_a
+    enum2 = enum1.filter(&pr2)
+    assert_equal(arr1, enum1.to_a)
+  end
+
+  def test_filter_not_same
+    enum1 = [].filter
+    enum2 = enum1.filter
+    assert_not_same(enum1, enum2)
+  end
+
+  def test_filter!
+    enum1 = [].filter
+    enum2 = enum1.filter!
+    assert_same(enum1, enum2)
+  end
+
+  def test_init_block
+    range = -10..10
+    cnt = 0
+    init_pr = Proc.new{cnt = 0}
+    filter_pr = Proc.new{(cnt+=1)<=10}
+    enum = Enumerable::Filter.new range, init_pr, filter_pr
+    assert_equal([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], enum.to_a)
+  end
+
+  def test_filter_with_initproc_1
+    range = -10..10
+    cnt = 0
+    init_pr = Proc.new{cnt = 0}
+    filter_pr = Proc.new{(cnt+=1)<=10}
+    enum = range.filter_with_initproc init_pr, &filter_pr
+    assert_equal([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], enum.to_a)
+    # v-- same result when execute twice or more
+    assert_equal([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], enum.to_a)
+  end
+
+  def test_filter_with_initproc_2
+    range = 1..20
+    sum = 100
+    init_pr = Proc.new{sum = 0}
+    enum1 = range.filter_with_initproc(init_pr) {|n|(sum+=n)>100}
+    enum2 = enum1.filter(&:odd?)
+    # assert_not_equal([1, 3, 5, 7, 9, 11, 13, 15, 17, 19], enum2.to_a)
+    assert_equal([15, 17, 19], enum2.to_a)
+  end
+
+  def test_filter_with_throw_do_break
+    range = 1..20
+    sum = 0
+    init_pr = Proc.new{sum = 0}
+    enum = range.filter_with_initproc(init_pr) {|n|throw :do_break if (sum+=n)>100;true}
+    assert_equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], enum.to_a)
+  end
+end

data/test/test_transform.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'enumerable_lz'
+
+class TransformTest < Test::Unit::TestCase
+  def test_instance
+    enum = Enumerable::Transform.new []
+    assert_not_nil(enum)
+    assert_kind_of(Enumerable, enum)
+  end
+
+  def test_transform_array
+    array = %w[Yes I have a number]
+    enum = array.transform{|letters|letters.swapcase}
+    assert_instance_of(Enumerable::Transform, enum)
+    assert_equal(%w[yES i HAVE A NUMBER], enum.to_a)
+  end
+
+  def test_multi_transform_1
+    range = -10..10
+    pr1 = lambda{|n|n**2}
+    pr2 = lambda{|n|10-n}
+    enum1 = range.transform(&pr1).transform(&pr2)
+    assert_equal(range.map{|n|10-n**2}, enum1.to_a)
+  end
+
+  def test_multi_transform_2
+    range = -10..10
+    pr1 = lambda{|n|n**2}
+    pr2 = lambda{|n|10-n}
+    enum2 = range.transform(&pr2).transform(&pr1)
+    assert_equal(range.map{|n|(10-n)**2}, enum2.to_a)
+  end
+
+  def test_multi_transform_3
+    range = -10..10
+    pr1 = lambda{|n|n**2}
+    pr2 = lambda{|n|10-n}
+    enum1 = range.transform(&pr1)
+    arr1 = enum1.to_a
+    enum1.transform(&pr2)
+    assert_equal(arr1, enum1.to_a)
+  end
+
+  def test_transform_not_same
+    enum1 = [].transform
+    enum2 = enum1.transform
+    assert_not_same(enum1, enum2)
+  end
+
+  def test_transform!
+    enum1 = [].transform
+    enum2 = enum1.transform!
+    assert_same(enum1, enum2)
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: enumerable_lz
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- antimon2
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-23 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: Add Enumerable#filter, Enumerable#transform and some equivalent methods on Enumerable with suffix '_lz'.
+email: antimon2.me@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- LICENSE.txt
+- ChangeLog
+- Rakefile
+- test/test_enumerable_ex.rb
+- test/test_filter.rb
+- test/test_transform.rb
+- lib/enumerable_lz/enumerable_ex.rb
+- lib/enumerable_lz/filter.rb
+- lib/enumerable_lz/filter_18.rb
+- lib/enumerable_lz/filter_mrb.rb
+- lib/enumerable_lz/transform.rb
+- lib/enumerable_lz/transform_18.rb
+- lib/enumerable_lz/transform_mrb.rb
+- lib/enumerable_lz.rb
+has_rdoc: true
+homepage: https://github.com/antimon2/enumerable_lz
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: enumerable_lz
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Add Enumerable#filter, Enumerable#transform and some equivalent methods on Enumerable with suffix '_lz'.
+test_files: 
+- test/test_enumerable_ex.rb
+- test/test_filter.rb
+- test/test_transform.rb