filter 0.0.3 → 0.0.4

data/README.rdoc

@@ -1,22 +1,26 @@
 == Synopsys
-Enumerable#filter - extended Enumerable#select
+<code>Enumerable#filter</code> - extended <code>Enumerable#select</code>
 
 == Examples
-String filter (acts like Enumerable#grep):
+String filter (acts like <code>Enumerable#grep</code>):
   [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:
+You can pass a <code>Proc</code> or <code>Symbol</code>. Methods and blocks are allowed too:
   [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:
+<code>Enumerable#filter</code> can match against enumerable items attributes. Like this:
   [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.
+If the block is supplied, each matching element is passed to it, and the block's result is stored in the output array.
   [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:
+<code>Enumerable#filter</code> also accepts <code>true</code> or <code>false</code> as argument:
   [0, false, 2, nil].filter(true)          # => [0, 2]
   [0, false, 2, nil].filter(false)         # => [false, nil]
+
+<code>Enumerable#filter</code> also supports <code>OR</code> operator!
+Just pass many patterns, they will be joined together with <code>OR</code> operator.
+  [0, 2, 3, 4].filter(:zero?, :odd?)       # => [0, 3]

data/lib/filter.rb

@@ -1,8 +1,8 @@
-# == Synpsys
-# Extension for Ruby Enumerable module
+# == Synopsys
+# Extension for Ruby <code>Enumerable</code> module
 #
 # == Description
-# Extends Enumerable module with +filter+ method - enhanced version of Enumerable#select
+# Extends <code>Enumerable</code> module with <code>filter</code> method - enhanced version of <code>Enumerable#select</code>.
 #
 # == Examples
 #   [1, 2, 3, 'ab'].filter(/a/)               # => ['ab']
@@ -11,50 +11,69 @@
 #   [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]
+#
+# <code>Enumerable#filter</code> also supports <code>OR</code> operator! Just pass many patterns as arguments.
+# This snippet will match elements responding to <code>zero?</code> or <code>odd?</code> methods with <code>true</code>.
+#   [0, 2, 3, 4].filter(:zero?, :odd?)        # => [0, 3]
 module Enumerable
   # Extended Enumerable#select combibed with Enumerable#collect
   #
-  # When String or Regexp passed it acts as built-in +grep+ method, but return Enumerator instead of Array
-  # Also you can pass Symbol, Proc or block
+  # When String or Regexp passed it acts as built-in <code>Enumerable#grep</code> method
+  # Also you can pass <code>Symbol, Proc, Method, Array, Hash, Class, Module, true, false, nil</code>.
+  # If the <code>block</code> is supplied without other arguments it will be used as filter.
+  # If the <code>block</code> is supplied with <code>patterns</code>,
+  # each matching element is passed to it, and the block's result is stored in the output array.
   #
-  # @param pattern [Numeric|String|Regexp|Symbol|Proc|Method|NilClass|Hash|TrueClass|FalseClass|Module|Class]
+  # @param patterns *[Numeric|String|Regexp|Symbol|Proc|Method|NilClass|Hash|TrueClass|FalseClass|Module|Class]
   # @param block [Proc]
-  def filter(pattern = nil, &block) # :yields: obj
-    pattern, block = block, nil if block_given? && pattern.nil?
+  # @return [Enumerable]
+  def filter(*patterns, &block) # :yields: obj
+    # do nothing on null input
+    return self if !block_given? && patterns.empty?
+
+    # move +block+ to +patterns+ if no +patterns+ given
+    patterns, block = [block], nil if block_given? && patterns.empty?
+    conditions = patterns.map { |pattern| filter_condition(pattern) }
+
+    # match elements against all patterns using +OR+ operator
+    filtered = select do |obj|
+      conditions.any? { |condition| condition.call(obj) }
+    end
 
-    filtered = case pattern
-      when NilClass then self
+    # also transform elements if block given
+    block ? filtered.map(&block) : filtered
+  end
+
+  private
+  def filter_condition(pattern) #:nodoc:
+    # create filter condition from pattern
+    case pattern
+      when NilClass then proc { true }
 
       when Class, Module then
-        select do |e|
+        proc do |e|
           e.is_a?(Class) || e.is_a?(Module) ?
               e <= pattern :
               e.is_a?(pattern)
         end
 
-      when Symbol, Proc, Method then select(&pattern.to_proc)
+      when Symbol, Proc, Method then pattern.to_proc
 
       when Array then # enum.filter [:even?, :positive?, :cool?, proc { |n| n < 10 }]
-        pattern.reduce(self) do |chain, local_pattern|
-          chain.select(&local_pattern.to_proc)
+        proc do |e|
+          pattern.all? { |condition| filter_condition(condition).call(e) }
         end
 
       when Hash then # enum.filter :to_i => :even?, :ceil => :odd?
-        pattern.reduce(self) do |chain, pair|
-          attr, local_pattern = pair.map(&:to_proc)
-
-          chain.select do |element|
-            local_pattern.call(attr.call(element))
+        proc do |e|
+          pattern.all? do |attribute, condition|
+            filter_condition(condition).call(attribute.to_proc.call(e))
           end
         end
 
-      when TrueClass, FalseClass then select { |e| !!e == pattern }
+      when TrueClass, FalseClass then proc { |e| !!e == pattern }
 
-      else select { |e| pattern === e } # otherwise - String, Regexp, Numeric etc.
+      else proc { |e| pattern === e } # otherwise - String, Regexp, Numeric etc.
     end
-
-    # also transform elements if block given
-    block ? filtered.map(&block) : filtered
   end
-
-end
+end

data/lib/filter/version.rb

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

data/spec/filter_spec.rb

@@ -53,4 +53,8 @@ describe Enumerable do
     [0, false, 2, nil].filter(true).should == [0, 2]
     [0, false, 2, nil].filter(false).should == [false, nil]
   end
+
+  it "should match using OR operator" do
+    [0, 2, 3, 4].filter(:zero?, :odd?).should == [0, 3]
+  end
 end

metadata

@@ -1,52 +1,48 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: filter
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Alexey Mikhaylov
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-12-12 00:00:00 +06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-12-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &20615240 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  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/)              # => ['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: 
+  prerelease: false
+  version_requirements: *20615240
+description: ! "== Synopsys\n<code>Enumerable#filter</code> - extended <code>Enumerable#select</code>\n\n==
+  Examples\nString filter (acts like <code>Enumerable#grep</code>):\n  [1, 2, 3, 'ab'].filter(/a/)
+  \             # => ['ab']\n  [1, 2, 3, '3'].filter('3')               # => ['3']\n\nYou
+  can pass a <code>Proc</code> or <code>Symbol</code>. 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<code>Enumerable#filter</code>
+  can match against enumerable items attributes. Like this:\n  [1, 2, 3, 4.2].filter
+  :to_i => :even?    # => [2, 4]\n\nIf the block is supplied, each matching element
+  is passed to it, and the block's result is stored in the output array.\n  [1, 2,
+  4].filter(&:even?) { |n| n + 1 }  # => [3, 5]\n\n<code>Enumerable#filter</code>
+  also accepts <code>true</code> or <code>false</code> as argument:\n  [0, false,
+  2, nil].filter(true)          # => [0, 2]\n  [0, false, 2, nil].filter(false)         #
+  => [false, nil]\n\n<code>Enumerable#filter</code> also supports <code>OR</code>
+  operator!\nJust pass many patterns, they will be joined together with <code>OR</code>
+  operator.\n  [0, 2, 3, 4].filter(:zero?, :odd?)       # => [0, 3]"
+email:
 - amikhailov83@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - LICENSE
@@ -57,37 +53,28 @@ files:
 - lib/filter/version.rb
 - spec/filter_spec.rb
 - spec/test_helper.rb
-has_rdoc: true
 homepage: https://github.com/take-five/filter
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: filter
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Enumerable#filter - extended Enumerable#select combined with Enumerable#collect
 test_files: []
-