filter 0.0.2 → 0.0.3

data/README.rdoc

@@ -3,20 +3,20 @@ Enumerable#filter - extended Enumerable#select
 
 == Examples
 String filter (acts like Enumerable#grep):
-  [1, 2, 3, 'ab'].filter(/a/)              # => #<Enumerator: ['ab']>
-  [1, 2, 3, '3'].filter('3')               # => #<Enumerator: ['3']>
+  [1, 2, 3, 'ab'].filter(/a/)              # => ['ab']
+  [1, 2, 3, '3'].filter('3')               # => ['3']
 
 You can pass a <tt>Proc</tt> or <tt>Symbol</tt>. Methods and blocks are allowed too:
-  [1, 2, 3].filter(&:even?)                # => #<Enumerator: [2]>
-  [1, 2, 3].filter(:even?)                 # => #<Enumerator: [2]>
-  [1, 2, 4].filter { |num| num.even? }     # => #<Enumerator: [2, 4]>
+  [1, 2, 3].filter(&:even?)                # => [2]
+  [1, 2, 3].filter(:even?)                 # => [2]
+  [1, 2, 4].filter { |num| num.even? }     # => [2, 4]
 
 <tt>Enumerable#filter</tt> can match against enumerable items attributes. Like this:
-  [1, 2, 3, 4.2].filter :to_i => :even?    # => #<Enumerator: [2, 4]>
+  [1, 2, 3, 4.2].filter :to_i => :even?    # => [2, 4]
 
 If the block is supplied, each matching element is passed to it, and the block’s result is stored in the output enumerator.
-  [1, 2, 4].filter(&:even?) { |n| n + 1 }  # => #<Enumerator: [3, 5]>
+  [1, 2, 4].filter(&:even?) { |n| n + 1 }  # => [3, 5]
 
 <tt>Enumerable#filter</tt> also accepts <tt>true</tt> or <tt>false</tt> as argument:
-  [0, false, 2, nil].filter(true)          # => #<Enumerator: [0, 2]>
-  [0, false, 2, nil].filter(false)         # => #<Enumerator: [false, nil]>
+  [0, false, 2, nil].filter(true)          # => [0, 2]
+  [0, false, 2, nil].filter(false)         # => [false, nil]

data/filter.gemspec

@@ -20,6 +20,5 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'deferred_enum'
   s.add_development_dependency "rspec"
 end

data/lib/filter.rb

@@ -1,5 +1,3 @@
-require 'deferred_enum'
-
 # == Synpsys
 # Extension for Ruby Enumerable module
 #
@@ -7,12 +5,12 @@ require 'deferred_enum'
 # Extends Enumerable module with +filter+ method - enhanced version of Enumerable#select
 #
 # == Examples
-#   [1, 2, 3, 'ab'].filter(/a/)               # => #<Enumerator: ['ab']>
-#   [1, 2, 3].filter(&:even?)                 # => #<Enumerator: [2]>
-#   [1, 2, 3, 4.2].filter :to_i => :even?     # => #<Enumerator: [2, 4]>
-#   [1, 2, 4].filter { |num| num.even? }      # => #<Enumerator: [2, 4]>
-#   [1, 2, 4].filter(:even?) { |n| n + 1 }    # => #<Enumerator: [3, 5]>
-#   [0, false, 2, nil].filter(true)           # => #<Enumerator: [0, 2]>
+#   [1, 2, 3, 'ab'].filter(/a/)               # => ['ab']
+#   [1, 2, 3].filter(&:even?)                 # => [2]
+#   [1, 2, 3, 4.2].filter :to_i => :even?     # => [2, 4]
+#   [1, 2, 4].filter { |num| num.even? }      # => [2, 4]
+#   [1, 2, 4].filter(:even?) { |n| n + 1 }    # => [3, 5]
+#   [0, false, 2, nil].filter(true)           # => [0, 2]
 module Enumerable
   # Extended Enumerable#select combibed with Enumerable#collect
   #
@@ -25,24 +23,24 @@ module Enumerable
     pattern, block = block, nil if block_given? && pattern.nil?
 
     filtered = case pattern
-      when NilClass then defer
+      when NilClass then self
 
       when Class, Module then
-        defer.select do |e|
+        select do |e|
           e.is_a?(Class) || e.is_a?(Module) ?
               e <= pattern :
               e.is_a?(pattern)
         end
 
-      when Symbol, Proc, Method then defer.select(&pattern.to_proc)
+      when Symbol, Proc, Method then select(&pattern.to_proc)
 
       when Array then # enum.filter [:even?, :positive?, :cool?, proc { |n| n < 10 }]
-        pattern.reduce(self.defer) do |chain, local_pattern|
+        pattern.reduce(self) do |chain, local_pattern|
           chain.select(&local_pattern.to_proc)
         end
 
       when Hash then # enum.filter :to_i => :even?, :ceil => :odd?
-        pattern.reduce(self.defer) do |chain, pair|
+        pattern.reduce(self) do |chain, pair|
           attr, local_pattern = pair.map(&:to_proc)
 
           chain.select do |element|
@@ -50,9 +48,9 @@ module Enumerable
           end
         end
 
-      when TrueClass, FalseClass then defer.select { |e| !!e == pattern }
+      when TrueClass, FalseClass then select { |e| !!e == pattern }
 
-      else defer.select { |e| pattern === e } # otherwise - String, Regexp, Numeric etc.
+      else select { |e| pattern === e } # otherwise - String, Regexp, Numeric etc.
     end
 
     # also transform elements if block given

data/lib/filter/version.rb

@@ -1,3 +1,3 @@
 module Filter
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/filter_spec.rb

@@ -1,39 +1,39 @@
 require File.expand_path('../test_helper', __FILE__)
 
 describe Enumerable do
-  it "should return Enumerator" do
+  it "should return Enumerable" do
     result = [1, 2, 3].filter
 
-    result.should be_a(Enumerator)
+    result.should be_a(Enumerable)
   end
 
   it "should return equivalent Enumerator on null input" do
-    [1, 2].filter.to_a.should == [1, 2]
+    [1, 2].filter.should == [1, 2]
   end
 
   it "should match regular expressions" do
-    [1, 2, 3, 'ba'].filter(/ba/).to_a.should == ['ba']
+    [1, 2, 3, 'ba'].filter(/ba/).should == ['ba']
   end
 
   it "should match against symbols" do
-    [1, 2, 3].filter(:even?).to_a.should == [2]
+    [1, 2, 3].filter(:even?).should == [2]
   end
 
   it "should match against lambdas" do
-    [1, 2, 3].filter(lambda{|n| n.even?}).to_a.should == [2]
+    [1, 2, 3].filter(lambda{|n| n.even?}).should == [2]
   end
 
   it "should match against blocks" do
-    [1, 2, 3].filter { |n| n.even? }.to_a.should == [2]
+    [1, 2, 3].filter { |n| n.even? }.should == [2]
   end
 
   it "should support #map" do
-    [1, 2, 3].filter(:even?) { |n| n + 1 }.to_a.should == [3]
+    [1, 2, 3].filter(:even?) { |n| n + 1 }.should == [3]
   end
 
   it "should match against Hash" do
-    [1, 2, 3, 4.2].filter(:to_i => :even?).to_a.should == [2, 4.2]
-    [2, 3, 4.2].filter(:to_i => :even?, :ceil => :odd?).to_a.should == [4.2]
+    [1, 2, 3, 4.2].filter(:to_i => :even?).should == [2, 4.2]
+    [2, 3, 4.2].filter(:to_i => :even?, :ceil => :odd?).should == [4.2]
   end
 
   it "should match against Class and Module" do
@@ -41,16 +41,16 @@ describe Enumerable do
     m = Module.new {}
     i = c.new
 
-    [c, i, 1].filter(c).to_a.should == [c, i]
-    [c, m, i, 1].filter(m).to_a.should == [m]
+    [c, i, 1].filter(c).should == [c, i]
+    [c, m, i, 1].filter(m).should == [m]
   end
 
   it "should match against Array" do
-    [0, 1].filter([:even?, :zero?]).to_a.should == [0]
+    [0, 1].filter([:even?, :zero?]).should == [0]
   end
 
   it "should match against true or false" do
-    [0, false, 2, nil].filter(true).to_a.should == [0, 2]
-    [0, false, 2, nil].filter(false).to_a.should == [false, nil]
+    [0, false, 2, nil].filter(true).should == [0, 2]
+    [0, false, 2, nil].filter(false).should == [false, nil]
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Alexey Mikhaylov
@@ -14,26 +14,13 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-11 00:00:00 +06:00
+date: 2011-12-12 00:00:00 +06:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: deferred_enum
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -42,15 +29,15 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id002
+  version_requirements: *id001
 description: "== Synopsys\n\
   Enumerable#filter - extended Enumerable#select\n\n\
   == Examples\n\
-  String filter (acts like Enumerable#grep):\n  [1, 2, 3, 'ab'].filter(/a/)              # => #<Enumerator: ['ab']>\n  [1, 2, 3, '3'].filter('3')               # => #<Enumerator: ['3']>\n\n\
-  You can pass a <tt>Proc</tt> or <tt>Symbol</tt>. Methods and blocks are allowed too:\n  [1, 2, 3].filter(&:even?)                # => #<Enumerator: [2]>\n  [1, 2, 3].filter(:even?)                 # => #<Enumerator: [2]>\n  [1, 2, 4].filter { |num| num.even? }     # => #<Enumerator: [2, 4]>\n\n\
-  <tt>Enumerable#filter</tt> can match against enumerable items attributes. Like this:\n  [1, 2, 3, 4.2].filter :to_i => :even?    # => #<Enumerator: [2, 4]>\n\n\
-  If the block is supplied, each matching element is passed to it, and the block\xE2\x80\x99s result is stored in the output enumerator.\n  [1, 2, 4].filter(&:even?) { |n| n + 1 }  # => #<Enumerator: [3, 5]>\n\n\
-  <tt>Enumerable#filter</tt> also accepts <tt>true</tt> or <tt>false</tt> as argument:\n  [0, false, 2, nil].filter(true)          # => #<Enumerator: [0, 2]>\n  [0, false, 2, nil].filter(false)         # => #<Enumerator: [false, nil]>\n"
+  String filter (acts like Enumerable#grep):\n  [1, 2, 3, 'ab'].filter(/a/)              # => ['ab']\n  [1, 2, 3, '3'].filter('3')               # => ['3']\n\n\
+  You can pass a <tt>Proc</tt> or <tt>Symbol</tt>. Methods and blocks are allowed too:\n  [1, 2, 3].filter(&:even?)                # => [2]\n  [1, 2, 3].filter(:even?)                 # => [2]\n  [1, 2, 4].filter { |num| num.even? }     # => [2, 4]\n\n\
+  <tt>Enumerable#filter</tt> can match against enumerable items attributes. Like this:\n  [1, 2, 3, 4.2].filter :to_i => :even?    # => [2, 4]\n\n\
+  If the block is supplied, each matching element is passed to it, and the block\xE2\x80\x99s result is stored in the output enumerator.\n  [1, 2, 4].filter(&:even?) { |n| n + 1 }  # => [3, 5]\n\n\
+  <tt>Enumerable#filter</tt> also accepts <tt>true</tt> or <tt>false</tt> as argument:\n  [0, false, 2, nil].filter(true)          # => [0, 2]\n  [0, false, 2, nil].filter(false)         # => [false, nil]\n"
 email: 
 - amikhailov83@gmail.com
 executables: []