enumerable_lz 0.1.4 → 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ad8aeb48998541b0d13a8e20a63aa5d2b6af5ba
+  data.tar.gz: 7f66a110548e37e864bee992327c67ad36580dd4
+SHA512:
+  metadata.gz: b7847ff329ce9a00831d66525d7dc5f91fadbe4f33a3a249dcc1cea959eaef37795ab0648e127be80b26ae1a3a83d913a304aa9670b2f76d7269b379a5f9fcbe
+  data.tar.gz: 5511760da227ab917f450a4c9c2af7475d5e88923a374de2d8b1a780edb909fcc1b30b81d9b3c79f5c560e881c22c9a831a4ac900c80f4e1f49487ace01aa745

data/ChangeLog

@@ -14,3 +14,9 @@
 
 * Improve performance much more
 
+== 0.1.5 / 2014-01-08
+
+* Add `filter.with_index` and `transform.with_index` feature
+* Add `filter.with_initializer` feature (and obsolete `filter_with_initproc` method)
+* Add support for Ruby 2.0.0/2.1.0
+* Improve performance

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2011 GOTOH Shunsuke (@antimon2)
+Copyright (c) 2011,2014 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

data/README.md

@@ -9,17 +9,32 @@ Also it provides lazy equivalents of some methods in `Enumerable`.
 When require 'enumerable_lz', these lazy methods are provided:
 
 * `Enumerable#filter`
-* `Enumerable#filter_with_initproc`
 * `Enumerable#transform`
 
-For example (in Ruby 1.9.x):
+And some method-chains are provided:
+
+* `Enumerable#filter.with_index`
+* `Enumerable#filter.with_initializer`
+* `Enumerable#transform.with_index`
+
+For example (in Ruby 1.9.x or greater):
 
     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.
 
+    Prime.filter.with_index{|q,i|i.odd?}.take(10)
+    # => [3, 7, 13, 19, 29, 37, 43, 53, 61, 71]
+
+    Prime.transform.with_index{|q,i|[q,i]}.take(10)
+    # => [[2, 0], [3, 1], [5, 2], [7, 3], [11, 4], [13, 5], [17, 6], [19, 7], [23, 8], [29, 9]]
+
+    # especially, when calling transform.with_index without a block
+    Prime.transform.with_index.take(10)
+    # => [[2, 0], [3, 1], [5, 2], [7, 3], [11, 4], [13, 5], [17, 6], [19, 7], [23, 8], [29, 9]]
+
 
 ## Expanded Usage
 
@@ -37,7 +52,7 @@ When require 'enumerable_lz/enumerable_ex', some lazy methods equivalents to ori
 * `Enumerable#take_while_lz`
 
 
-For example (in Ruby 1.9.x):
+For example (in Ruby 1.9.x or greater):
 
     require 'enumerable_lz'
     require 'enumerable_lz/enumerable_ex'
@@ -51,10 +66,12 @@ These expanded methods are inplemented with fundamental filter and transformatio
 
 ## Supported Rubies
 
-* Ruby 1.9.x (testing 1.9.2 p-180)
-* Ruby 1.8.7 (testing 1.8.7-p334)
-* JRuby (testing 1.5.6, 1.6.0)
-* MacRuby (testing 0.9)
+* Ruby 2.1.0 (testing 2.1.0-p0)
+* Ruby 2.0.0 (testing 2.0.0-p247)
+* Ruby 1.9.x (testing 1.9.3-p448)
+* Ruby 1.8.7 (testing 1.8.7-p358)
+* JRuby (testing 1.7.2)
+* MacRuby (testing 0.12)
 
 ## Installation
 
@@ -64,6 +81,6 @@ These expanded methods are inplemented with fundamental filter and transformatio
 ## License
 
 The MIT License  
-Copyright (c) 2011 GOTOH Shunsuke (@antimon2)
+Copyright (c) 2011, 2014 GOTOH Shunsuke (@antimon2)
 
 Please see [LICENSE.txt](LICENSE.txt) for details.

data/lib/enumerable_lz.rb

@@ -11,8 +11,48 @@ else
   require File.dirname(__FILE__)+'/enumerable_lz/transform_18'
 end
 
+# add {#filter} and {#transform} methods.
 module Enumerable
+  # @!group Fundamental Method Summary
+
+  # Filter by pattern or block
+  # @yield [el] 
+  # @overload filter(&block)
+  #   filter by block
+  #   @yield [el] filterring block.
+  #   @yieldparam el each element of original Enumerable
+  #   @yieldreturn [Boolean]
+  #   @return [Enumerator::Filter]
+  # @overload filter(pattern)
+  #   filter by pattern
+  #   @param [#===] pattern filterring pattern. (uses === method)
+  #   @return [Enumerator::Filter]
+  # @return [Enumerator::Filter]
+  def filter pattern = nil, &block
+    Enumerator::Filter.new self, pattern||block
+  end
+
+  # @yield [el] 
+  # @deprecated Use filter.with_initializer instead of this method
+  # @see Enumerator::Filter#with_initializer
+  # @return [Enumerator::Filter]
+  def filter_with_initproc init_proc, pattern = nil, &block
+    filter.with_initializer init_proc, pattern = nil, &block
+  end
+
+  # Transform by block
+  # @yield [el] transform block.
+  # @yieldparam el each element of original Enumerable
+  # @yieldreturn [Object]
+  # @return [Enumerator::Transform]
+  def transform &block
+    Enumerator::Transform.new self, &block
+  end
+
+  # @!endgroup
+
+  # @private
   module EnumerableLz
-    VERSION = "0.1.4"
+    VERSION = "0.1.5"
   end
-end
+end

data/lib/enumerable_lz/enumerable_ex.rb

@@ -1,49 +1,91 @@
 require File.expand_path('..', __FILE__)
 
 module Enumerable
+  # @!group Expanded Method Summary
+
+  # lazy equivalent of `Enumerable#select`
+  # @yield [el]
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @return [Enumerator::Filter]
   def select_lz &block
     filter &block
   end
-
   alias :find_all_lz :select_lz
 
+  # lazy equivalent of `Enumerable#reject`
+  # @yield [el]
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @return [Enumerator::Filter]
   def reject_lz &block
     filter {|e|!block.call(e)}
   end
 
+  # lazy equivalent of `Enumerable#grep`
+  # @yield [el]
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @overload grep_lz(pattern)
+  #   @return [Enumerator::Filter]
+  # @overload grep_lz(pattern, &block)
+  #   @yield [el]
+  #   @return [Enumerator::Transform]
+  # @return [Enumerator::Filter, Enumerator::Transform]
   def grep_lz pattern, &block
     enum = filter pattern
     block_given? ? enum.transform(&block) : enum
   end
 
-  alias :map_lz :transform
+  # @!method map_lz(&block)
+  #   lazy equivalent of `Enumerable#map`
+  #   @yield [el]
+  #   @note available only requiring "enumerable_lz/enumerable_ex"
+  #   @return [Enumerator::Transform]
+  self.__send__(:alias_method, :map_lz, :transform)
   alias :collect_lz :map_lz
 
+  # lazy equivalent of `Enumerable#drop`
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @return [Enumerator::Filter]
   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}
+    # cnt = 0
+    # filter_with_initproc(Proc.new{cnt=0}) {|el| (cnt+=1) > n}
+    filter.with_index {|el, i| i >= n}
   end
 
+  # lazy equivalent of `Enumerable#drop_while`
+  # @yield [el]
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @return [Enumerator::Filter]
   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)}
+    # filter_with_initproc(Proc.new{flg=false}) {|el|flg || (!block.call(el) ? flg = true : false)}
+    filter.with_initializer(Proc.new{flg=false}) {|el|flg || (!block.call(el) ? flg = true : false)}
   end
 
+  # lazy equivalent of `Enumerable#take`
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @return [Enumerator::Filter]
   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}
+    # cnt = 0
+    # filter_with_initproc(Proc.new{cnt=0}) {|el| throw :do_break if (cnt+=1) > n;true}
+    filter.with_index {|el, i| throw :do_break if i >= n; true}
   end
 
+  # lazy equivalent of `Enumerable#take_while`
+  # @yield [el]
+  # @note available only requiring "enumerable_lz/enumerable_ex"
+  # @return [Enumerator::Filter]
   def take_while_lz &block
     return self if !block_given?
-    filter {|el|throw :do_break unless block.call(el);true}
+    filter {|el|throw :do_break unless block.call(el); true}
   end
 
+  # @!endgroup
+
 #  def zip_lz *lists
 #    enums = lists.map{|list|list.each rescue [].each}
 #    Enumerator.new do |y|

data/lib/enumerable_lz/filter.rb

@@ -1,21 +1,14 @@
-# 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
+# -- for Ruby1.9.x except for MacRuby
 
+# add [Filter] and [Transform] classes.
+class Enumerator
+  # Lazy Filterring Enumerator
   class Filter < Enumerator
-    def initialize obj, *args
-      the_filter = args.shift
-      init_block, the_filter = [the_filter, args.shift] unless args.empty?
+    # @param [Enumerable] obj an Enumerable.
+    # @param [#===] the_filter filterring pattern or proc.
+    def initialize obj, the_filter=nil
       @org_enum = obj
-      @init_block = init_block unless init_block.nil?
       super() do |y|
-        @init_block.call unless @init_block.nil?
         compiled_filter = @filter.nil? ? Proc.new{true} : lambda{|f|
           break f[0] if f.size==1
           codes = f.size.times.map do |idx|
@@ -32,6 +25,9 @@ module Enumerable
       filter! the_filter if the_filter
     end
 
+    # Apply filter pattern/block and return self. (bang method of filter)
+    # @yield [el]
+    # @return [Filter] self
     def filter! pattern=nil, &block
       @filter||=[]
       if pattern.is_a? Array
@@ -42,9 +38,15 @@ module Enumerable
       self
     end
 
-    #[override]
+    # [override] for performance
+    # @yield [el]
+    # @overload filter(&block)
+    #   @yield [el]
+    # @overload filter(pattern)
+    #   @param [#===] pattern
+    # @see Enumerable#filter Enumerable#filter
+    # @return [Filter]
     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
@@ -55,6 +57,33 @@ module Enumerable
       Filter.new @org_enum, patterns
     end
 
+    # @overload with_initializer(init_proc, &block)
+    #   filter by block with initializer proc.
+    #   @param [#call] init_proc initializer proc. (uses .call method)
+    #   @yield filterring block.
+    #   @return [Filter]
+    # @overload with_initializer(init_proc, pattern)
+    #   filter by pattern with initializer proc.
+    #   @param [#call] init_proc initializer proc. (uses .call method)
+    #   @param [#===] pattern filterring pattern. (uses === method)
+    #   @return [Filter]
+    # @return [Filter]
+    def with_initializer init_proc, pattern = nil, &block
+      src_enum = @filter.nil? ? @org_enum : self
+      FilterWithInitializer.new src_enum, init_proc, pattern||block
+    end
+
+    # @param [Numeric] offset offset.
+    # @yield [el, i] 
+    # @return [Filter]
+    def with_index offset=0, &block
+      raise ArgumentError, "tried to call filter.with_index without a block" unless block_given?
+      i = offset - 1
+      with_initializer(Proc.new{i = offset - 1}) do |el|
+        block.call(el, i += 1)
+      end
+    end
+
     private
     def conv_proc pattern
       case pattern
@@ -65,9 +94,31 @@ module Enumerable
       end
     end
   end
+
+  # @api private
+  class FilterWithInitializer < Filter
+    def initialize obj, init_block, the_filter = nil
+      super obj, the_filter
+      @initializer = init_block
+    end
+
+    def each &block
+      return self unless block_given?
+      @initializer.call
+      super &block
+    end
+
+    # @see Enumerable#filter Enumerable#filter
+    # @return [Filter]
+    def filter pattern=nil, &block
+      Filter.new self, pattern||block
+    end
+  end
+  private_constant :FilterWithInitializer if self.respond_to? :private_constant
 end
-#against the Bug on JRuby <1.6.2
+# against the Bug on JRuby < 1.6.2
 if !(Proc.new{true}===true)
+  # @private
   class Proc
     alias :=== :call
   end

data/lib/enumerable_lz/filter_18.rb

@@ -1,76 +1,99 @@
 # for Ruby1.8.7
+
 module Enumerable
-  def filter pattern = nil, &block
-    Filter.new self, pattern||block
-  end
+  class Enumerator
+    class Filter < Enumerator
+      def initialize obj, the_filter=nil
+        filter! the_filter if the_filter
+        @org_enum = obj
+      end
 
-  def filter_with_initproc init_proc, pattern = nil, &block
-    Filter.new self, init_proc, pattern||block
-  end
+      def each &block
+        return self unless block_given?
+        # compiled_filter = (@filter||[Proc.new{true}]).inject do |r,f|
+        #   Proc.new{|el| r[el] && f[el]}
+        # end
+        compiled_filter = @filter.nil? ? Proc.new{true} : lambda{|f|
+          break f[0] if f.size==1
+          codes = f.size.times.map do |idx|
+            "f[#{idx}][el]"
+          end
+          eval "Proc.new{|el|"+codes.join(" && ")+"}"
+        }.call(@filter)
+        catch :do_break do
+          @org_enum.each do |el|
+            block.call(el) if compiled_filter[el]
+          end
+        end
+        self
+      end
 
-  class Filter < Enumerator
-    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 filter! pattern=nil, &block
+        @filter||=[]
+        if pattern.is_a? Array
+          pattern.each{|el| @filter << conv_proc(el)}
+        else
+          @filter << conv_proc(pattern || block)
+        end
+        self
+      end
 
-    def each &block
-      return self unless block_given?
-      @init_block.call unless @init_block.nil?
-      # compiled_filter = (@filter||[Proc.new{true}]).inject do |r,f|
-      #   Proc.new{|el| r[el] && f[el]}
-      # end
-      compiled_filter = @filter.nil? ? Proc.new{true} : lambda{|f|
-        break f[0] if f.size==1
-        codes = f.size.times.map do |idx|
-          "f[#{idx}][el]"
+      #[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
-        eval "Proc.new{|el|"+codes.join(" && ")+"}"
-      }.call(@filter)
-      catch :do_break do
-        @org_enum.each do |el|
-          block.call(el) if compiled_filter[el]
+        Filter.new @org_enum, patterns
+      end
+
+      def with_initializer init_proc, pattern = nil, &block
+        src_enum = @filter.nil? ? @org_enum : self
+        FilterWithInitializer.new src_enum, init_proc, pattern||block
+      end
+
+      #[override]
+      def with_index offset=0, &block
+        raise ArgumentError, "tried to call filter.with_index without a block" unless block_given?
+        i = offset - 1
+        with_initializer(Proc.new{i = offset - 1}) do |el|
+          block.call(el, i += 1)
         end
       end
-      self
-    end
 
-    def filter! pattern=nil, &block
-      @filter||=[]
-      if pattern.is_a? Array
-        pattern.each{|el| @filter << conv_proc(el)}
-      else
-        @filter << conv_proc(pattern || block)
+      private
+      def conv_proc pattern
+        case pattern
+        when nil
+          Proc.new{true}
+        when Proc
+          pattern
+        else
+          pattern.respond_to?(:to_proc) ? pattern.to_proc : Proc.new{|el|pattern===el}
+        end
       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)
+    # private
+    class FilterWithInitializer < Filter
+      def initialize obj, init_block, the_filter = nil
+        super obj, the_filter
+        @initializer = init_block
+      end
+
+      def each &block
+        return self unless block_given?
+        @initializer.call
+        super &block
       end
-      Filter.new @org_enum, patterns
-    end
 
-    private
-    def conv_proc pattern
-      case pattern
-      when nil
-        Proc.new{true}
-      when Proc
-        pattern
-      else
-        pattern.respond_to?(:to_proc) ? pattern.to_proc : Proc.new{|el|pattern===el}
+      #[override]
+      def filter pattern=nil, &block
+        Filter.new self, pattern||block
       end
     end
   end
-end
+end

data/lib/enumerable_lz/filter_mrb.rb

@@ -1,24 +1,15 @@
 # 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 Enumerator
   class Filter < Enumerator
-    def initialize obj, *args
-      the_filter = args.shift
-      init_block, the_filter = [the_filter, args.shift] unless args.empty?
+    TrueProc = Proc.new{true}
+
+    def initialize obj, the_filter = nil
       @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?
           compiled_filter = outer.__send__(:compile_filter)
           catch :do_break do
             obj.each do |el|
@@ -50,10 +41,23 @@ module Enumerable
       else
         patterns<<(pattern || block)
       end
-      return Filter.new @org_enum, @init_block, patterns unless @init_block.nil?
       Filter.new @org_enum, patterns
     end
 
+    def with_initializer init_proc, pattern = nil, &block
+      src_enum = @filter.nil? ? @org_enum : self
+      FilterWithInitializer.new src_enum, init_proc, pattern||block
+    end
+
+    #[override]
+    def with_index offset=0, &block
+      raise ArgumentError, "tried to call filter.with_index without a block" unless block_given?
+      i = offset - 1
+      patterns = @filter.nil? ? [] : @filter.clone
+      patterns << Proc.new{|el| block.call(el, i += 1)}
+      FilterWithInitializer.new @org_enum, Proc.new{i = offset - 1}, patterns
+    end
+
     private
     def conv_proc pattern
       case pattern
@@ -74,4 +78,23 @@ module Enumerable
       }.call(@filter)
     end
   end
+
+  # private
+  class FilterWithInitializer < Filter
+    def initialize obj, init_block, the_filter = nil
+      super obj, the_filter
+      @initializer = init_block
+    end
+
+    def each &block
+      return self unless block_given?
+      @initializer.call
+      super &block
+    end
+
+    #[override]
+    def filter pattern=nil, &block
+      Filter.new self, pattern||block
+    end
+  end
 end

data/lib/enumerable_lz/transform.rb

@@ -1,10 +1,11 @@
-# for Ruby1.9.x except for MacRuby
-module Enumerable
-  def transform &block
-    Transform.new self, &block
-  end
+# -- for Ruby1.9.x except for MacRuby
 
+# add [Filter] and [Transform] classes.
+class Enumerator
+  # Lazy Transform Enumerator
   class Transform < Enumerator
+    # @param [Enumerable] obj an Enumerable.
+    # @yield transform block.
     def initialize obj, &transformer
       @org_enum = obj
       super() do |y|
@@ -16,13 +17,19 @@ module Enumerable
       transform! &transformer if block_given?
     end
 
+    # Apply another transformer block and return self. (bang method of transform)
+    # @yield [el] transform block.
+    # @return [Transform] self
     def transform! &block
       @transformer||=[]
       @transformer << block if block_given?
       self
     end
 
-    #[override]
+    # [override] for performance
+    # @yield [el] transform block.
+    # @see Enumerable#transform Enumerable#transform
+    # @return [Transform]
     def transform &block
       # clone.transform! &block
       cp = Transform.new @org_enum
@@ -32,6 +39,22 @@ module Enumerable
       cp.transform! &block
     end
 
+    # @yield [el, i] 
+    # @overload with_index(offset=0, &block)
+    #   @param [Numeric] offset offset.
+    #   @yield [el, i] 
+    #   @return [Transform]
+    # @overload with_index(offset=0)
+    #   @note same as with_index(offset) {|el, i| [el, i]}
+    #   @param [Numeric] offset offset.
+    #   @return [Transform]
+    # @return [Transform]
+    def with_index offset=0, &block
+      src_enum = @transformer.nil? || @transformer.size.zero? ? @org_enum : self
+      block ||= Proc.new{|el, i|[el, i]}
+      TransformWithIndex.new src_enum, offset, &block
+    end
+
     private
     def compile_transformer
       return Proc.new{|a|a} if @transformer.nil? || @transformer.size==0
@@ -44,4 +67,30 @@ module Enumerable
       }.call(@transformer)
     end
   end
+
+  # @api private
+  class TransformWithIndex < Transform
+    def initialize obj, offset = 0, &transformer
+      @org_enum = obj
+      @transformer = transformer.nil? ? nil : [transformer]
+      @offset = offset
+    end
+
+    def each
+      return self unless block_given?
+      the_transformer = @transformer[0] || Proc.new{|el,i|el}
+      i = @offset - 1
+      @org_enum.each do |el|
+        yield the_transformer.call(el, i+=1)
+      end
+    end
+
+    # @see Enumerable#filter Enumerable#filter
+    # @return [Transform]
+    def transform &block
+      Transform.new self, &block
+    end
+    alias :transform! :transform
+  end
+  private_constant :TransformWithIndex if self.respond_to? :private_constant
 end

data/lib/enumerable_lz/transform_18.rb

@@ -1,50 +1,79 @@
 # for Ruby1.8.7
 module Enumerable
-  def transform &block
-    Transform.new self, &block
-  end
+  class Enumerator
+    class Transform < Enumerator
+      def initialize obj, &transformer
+        @org_enum = obj
+        transform! &transformer if block_given?
+      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?
+        the_transformer = compile_transformer
+        @org_enum.each do |el|
+          block.call the_transformer[el]
+        end
+        self
+      end
 
-    def each &block
-      return self unless block_given?
-      the_transformer = compile_transformer
-      @org_enum.each do |el|
-        block.call the_transformer[el]
+      def transform! &block
+        @transformer||=[]
+        @transformer << block if block_given?
+        self
       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
 
-    #[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
+      #[override]
+      def with_index offset=0, &block
+        src_enum = @transformer.nil? || @transformer.size.zero? ? @org_enum : self
+        block ||= Proc.new{|el, i|[el, i]}
+        TransformWithIndex.new src_enum, offset, &block
+      end
+
+      private
+      def compile_transformer
+        return Proc.new{|a|a} if @transformer.nil? || @transformer.size==0
+        return @transformer[0] if @transformer.size==1
+        lambda{|t|
+          codes = t.size.times.inject "el" do |r,idx|
+            "t[#{idx}][#{r}]"
+          end
+          eval "Proc.new{|el|"+codes+"}"
+        }.call(@transformer)
+      end
     end
 
-    private
-    def compile_transformer
-      return Proc.new{|a|a} if @transformer.nil? || @transformer.size==0
-      return @transformer[0] if @transformer.size==1
-      lambda{|t|
-        codes = t.size.times.inject "el" do |r,idx|
-          "t[#{idx}][#{r}]"
+    # private
+    class TransformWithIndex < Transform
+      def initialize obj, offset = 0, &transformer
+        @org_enum = obj
+        @transformer = transformer.nil? ? nil : [transformer]
+        @offset = offset
+      end
+
+      def each
+        return self unless block_given?
+        the_transformer = @transformer[0] || Proc.new{|el,i|el}
+        i = @offset - 1
+        @org_enum.each do |el|
+          yield the_transformer.call(el, i+=1)
         end
-        eval "Proc.new{|el|"+codes+"}"
-      }.call(@transformer)
+      end
+
+      #[override]
+      def transform &block
+        Transform.new self, &block
+      end
+      alias :transform! :transform
     end
   end
 end

data/lib/enumerable_lz/transform_mrb.rb

@@ -1,9 +1,5 @@
 # for MacRuby
-module Enumerable
-  def transform &block
-    Transform.new self, &block
-  end
-
+class Enumerator
   class Transform < Enumerator
     def initialize obj, &transformer
       @org_enum = obj
@@ -36,6 +32,13 @@ module Enumerable
       cp.transform! &block
     end
 
+    #[override]
+    def with_index offset=0, &block
+      src_enum = @transformer.nil? || @transformer.size.zero? ? @org_enum : self
+      block ||= Proc.new{|el, i|[el, i]}
+      TransformWithIndex.new src_enum, offset, &block
+    end
+
     private
     def compile_transformer
       return Proc.new{|a|a} if @transformer.nil? || @transformer.size==0
@@ -52,4 +55,28 @@ module Enumerable
       # }.call(@transformer)
     end
   end
+
+  # private
+  class TransformWithIndex < Transform
+    def initialize obj, offset = 0, &transformer
+      @org_enum = obj
+      @transformer = transformer.nil? ? nil : [transformer]
+      @offset = offset
+    end
+
+    def each
+      return self unless block_given?
+      the_transformer = @transformer[0] || Proc.new{|el,i|el}
+      i = @offset - 1
+      @org_enum.each do |el|
+        yield the_transformer.call(el, i+=1)
+      end
+    end
+
+    #[override]
+    def transform &block
+      Transform.new self, &block
+    end
+    alias :transform! :transform
+  end
 end

data/test/test_filter.rb

@@ -3,15 +3,17 @@ require 'enumerable_lz'
 
 class FilterTest < Test::Unit::TestCase
   def test_instance
-    enum = Enumerable::Filter.new []
+    filter_class = RUBY_VERSION < "1.9.0" ? Enumerable::Enumerator::Filter : Enumerator::Filter
+    enum = filter_class.new []
     assert_not_nil(enum)
     assert_kind_of(Enumerable, enum)
   end
 
   def test_filter_array
+    filter_class = RUBY_VERSION < "1.9.0" ? Enumerable::Enumerator::Filter : Enumerator::Filter
     array = %w[Yes I have a number]
     enum = array.filter{|letters|letters.size > 1}
-    assert_instance_of(Enumerable::Filter, enum)
+    assert_instance_of(filter_class, enum)
     assert_equal(%w[Yes have number], enum.to_a)
   end
 
@@ -85,14 +87,15 @@ class FilterTest < Test::Unit::TestCase
     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_init_block
+  #   range = -10..10
+  #   cnt = 0
+  #   init_pr = Proc.new{cnt = 0}
+  #   filter_pr = Proc.new{(cnt+=1)<=10}
+  #   # enum = Enumerator::FilterWithInitializer.new range, init_pr, filter_pr
+  #   enum = Enumerator::FilterWithInitializer.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
@@ -122,4 +125,22 @@ class FilterTest < Test::Unit::TestCase
     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
+
+  def test_filetr_with_index
+    a = 0
+    b = (1..10).filter.with_index{|n,i|a=n;i.even?}.first
+    assert_equal([1, 1], [a, b])
+  end
+
+  def test_filetr_with_index_2
+    a = 0
+    b = (1..10).filter.with_index(1){|n,i|a=n;i.even?}.first
+    assert_equal([2, 2], [a, b])
+  end
+
+  def test_filetr_with_index_no_block
+    assert_raise(ArgumentError) do
+      (1..10).filter.with_index(2).take(2)
+    end
+  end
 end

data/test/test_transform.rb

@@ -3,15 +3,17 @@ require 'enumerable_lz'
 
 class TransformTest < Test::Unit::TestCase
   def test_instance
-    enum = Enumerable::Transform.new []
+    transform_class = RUBY_VERSION < "1.9.0" ? Enumerable::Enumerator::Transform : Enumerator::Transform
+    enum = transform_class.new []
     assert_not_nil(enum)
     assert_kind_of(Enumerable, enum)
   end
 
   def test_transform_array
+    transform_class = RUBY_VERSION < "1.9.0" ? Enumerable::Enumerator::Transform : Enumerator::Transform
     array = %w[Yes I have a number]
     enum = array.transform{|letters|letters.swapcase}
-    assert_instance_of(Enumerable::Transform, enum)
+    assert_instance_of(transform_class, enum)
     assert_equal(%w[yES i HAVE A NUMBER], enum.to_a)
   end
 
@@ -52,4 +54,24 @@ class TransformTest < Test::Unit::TestCase
     enum2 = enum1.transform!
     assert_same(enum1, enum2)
   end
+
+  def test_transform_with_index
+    range = -10..10
+    a = 0
+    result = range.transform.with_index{|n,i|n+a=i}.take(10)
+    assert_equal(9, a)
+  end
+
+  def test_transform_with_index2
+    range = -10..10
+    a = 0
+    result = range.transform.with_index{|n,i|n+a=i}.take(10)
+    assert_equal([-10, -8, -6, -4, -2, 0, 2, 4, 6, 8], result)
+  end
+
+  def test_transform_with_index_no_block
+    range = -10..10
+    result = range.transform.with_index(2).filter{|n,i|n+i<10}.to_a
+    assert_equal([[-10, 2], [-9, 3], [-8, 4], [-7, 5], [-6, 6], [-5, 7], [-4, 8], [-3, 9], [-2, 10]], result)
+  end
 end

metadata

@@ -1,28 +1,22 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: enumerable_lz
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.4
+version: !ruby/object:Gem::Version
+  version: 0.1.5
 platform: ruby
-authors: 
+authors:
 - antimon2
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-07 00:00:00 +09:00
-default_executable: 
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies: []
-
-description: Add Enumerable#filter, Enumerable#transform and some equivalent methods on Enumerable with suffix '_lz'.
+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: 
+files:
 - README.md
 - LICENSE.txt
 - ChangeLog
@@ -38,35 +32,35 @@ files:
 - 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: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: []
-
-require_paths: 
+rdoc_options:
+- --no-private
+- --exclude
+- (_mrb|_18)
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: enumerable_lz
-rubygems_version: 1.5.3
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 3
-summary: Add Enumerable#filter, Enumerable#transform and some equivalent methods on Enumerable with suffix '_lz'.
-test_files: 
+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
+has_rdoc: yard