filter 0.0.4 → 0.0.5

data/lib/filter.rb

@@ -1,3 +1,7 @@
+require "filter/condition"
+require "filter/or"
+require "filter/and"
+
 # == Synopsys
 # Extension for Ruby <code>Enumerable</code> module
 #
@@ -33,47 +37,12 @@ module Enumerable
 
     # 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
+    conditions = Filter.or(*patterns)
+
+    filtered = select { |obj| conditions === obj }
 
     # 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
-        proc do |e|
-          e.is_a?(Class) || e.is_a?(Module) ?
-              e <= pattern :
-              e.is_a?(pattern)
-        end
-
-      when Symbol, Proc, Method then pattern.to_proc
-
-      when Array then # enum.filter [:even?, :positive?, :cool?, proc { |n| n < 10 }]
-        proc do |e|
-          pattern.all? { |condition| filter_condition(condition).call(e) }
-        end
-
-      when Hash then # enum.filter :to_i => :even?, :ceil => :odd?
-        proc do |e|
-          pattern.all? do |attribute, condition|
-            filter_condition(condition).call(attribute.to_proc.call(e))
-          end
-        end
-
-      when TrueClass, FalseClass then proc { |e| !!e == pattern }
-
-      else proc { |e| pattern === e } # otherwise - String, Regexp, Numeric etc.
-    end
-  end
 end

data/lib/filter/and.rb

@@ -0,0 +1,18 @@
+require "filter/condition"
+
+module Filter
+  class And < Condition
+    def initialize(*patterns)
+      @matchers = patterns.map { |pattern| Matcher.new(pattern) }
+    end
+
+    def ===(other)
+      @matchers.all? { |m| m === other }
+    end
+  end
+
+  def and(*patterns)
+    And.new(*patterns)
+  end
+  module_function :and
+end

data/lib/filter/condition.rb

@@ -0,0 +1,23 @@
+require "filter/matcher"
+
+module Filter
+  class Condition
+    def initialize(pattern)
+      @matcher = Filter::Matcher.new(pattern)
+    end
+
+    def ===(another)
+      @matcher === another
+    end
+
+    def and(other)
+      Filter.and(self, other)
+    end
+    alias & and
+
+    def or(other)
+      Filter.or(self, other)
+    end
+    alias | or
+  end
+end

data/lib/filter/matcher.rb

@@ -0,0 +1,38 @@
+require "filter/matchers/base"
+require "filter/matchers/array"
+require "filter/matchers/boolean"
+require "filter/matchers/class"
+require "filter/matchers/hash"
+require "filter/matchers/nil"
+require "filter/matchers/symbol"
+
+module Filter
+  module Matcher
+    MAPPING = {
+      [NilClass] => Filter::Matchers::Nil,
+      [TrueClass, FalseClass] => Filter::Matchers::Boolean,
+      [Class, Module] => Filter::Matchers::Class,
+      [Array] => Filter::Matchers::Array,
+      [Symbol, Proc, Method, UnboundMethod] => Filter::Matchers::Symbol,
+      [Hash] => Filter::Matchers::Hash,
+    }
+
+    def new(pattern)
+      klass = nil
+
+      MAPPING.each_pair do |classes, matcher_klass|
+        klass = matcher_klass if classes.any? { |cls| pattern.is_a?(cls) }
+      end
+
+      klass = Filter::Matchers::Base if klass.nil?
+
+      klass.new(pattern)
+    end
+    module_function :new
+  end
+
+  def match(pattern)
+    Matcher.new(pattern)
+  end
+  module_function :match
+end

data/lib/filter/matchers/array.rb

@@ -0,0 +1,13 @@
+module Filter
+  module Matchers
+    class Array < Base
+      def initialize(pattern)
+        @pattern = pattern.map(&:to_proc)
+      end
+
+      def ===(other)
+        pattern.all? { |p| p === other }
+      end
+    end
+  end
+end

data/lib/filter/matchers/base.rb

@@ -0,0 +1,25 @@
+module Filter
+  module Matchers
+    class Base
+      attr_reader :pattern
+
+      def initialize(pattern)
+        @pattern = pattern
+      end
+
+      def ===(other)
+        pattern === other
+      end
+
+      def and(other)
+        Filter.and(self, other)
+      end
+      alias & and
+
+      def or(other)
+        Filter.or(self, other)
+      end
+      alias | or
+    end
+  end
+end

data/lib/filter/matchers/boolean.rb

@@ -0,0 +1,9 @@
+module Filter
+  module Matchers
+    class Boolean < Base
+      def ===(other)
+        !!other == pattern
+      end
+    end
+  end
+end

data/lib/filter/matchers/class.rb

@@ -0,0 +1,11 @@
+module Filter
+  module Matchers
+    class Class < Base
+      def ===(other)
+        other.is_a?(::Class) || other.is_a?(::Module) ?
+            other <= pattern :
+            other.is_a?(pattern)
+      end
+    end
+  end
+end

data/lib/filter/matchers/hash.rb

@@ -0,0 +1,15 @@
+module Filter
+  module Matchers
+    class Hash < Base
+      def initialize(pattern)
+        @pattern = ::Hash[pattern.map { |k, v| [k.to_proc, Filter::Matcher.new(v)]}]
+      end
+
+      def ===(other)
+        pattern.all? do |attr, pattern|
+          pattern === attr.call(other)
+        end
+      end
+    end
+  end
+end

data/lib/filter/matchers/nil.rb

@@ -0,0 +1,10 @@
+module Filter
+  module Matchers
+    class Nil < Base
+      # nil condition always results to true
+      def ===(other)
+        true
+      end
+    end
+  end
+end

data/lib/filter/matchers/symbol.rb

@@ -0,0 +1,13 @@
+module Filter
+  module Matchers
+    class Symbol < Base
+      def initialize(pattern)
+        @pattern = pattern.to_proc
+      end
+
+      def ===(other)
+        pattern.call(other)
+      end
+    end
+  end
+end

data/lib/filter/or.rb

@@ -0,0 +1,18 @@
+require "filter/condition"
+
+module Filter
+  class Or < Condition
+    def initialize(*patterns)
+      @matchers = patterns.map { |pattern| Matcher.new(pattern) }
+    end
+
+    def ===(other)
+      @matchers.any? { |m| m === other }
+    end
+  end
+
+  def or(*patterns)
+    Or.new(*patterns)
+  end
+  module_function :or
+end

data/lib/filter/version.rb

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

data/spec/filter_spec.rb

@@ -57,4 +57,14 @@ describe Enumerable do
   it "should match using OR operator" do
     [0, 2, 3, 4].filter(:zero?, :odd?).should == [0, 3]
   end
+
+  it "should be flexible" do
+    conditions = Filter.match(:even?) | :odd? | :zero?
+
+    [0, 1, 2].filter(conditions).should == [0, 1, 2]
+
+    # 0 and negative
+    conditions = Filter.and(:zero?, :even?) | proc { |n| n < 0 }
+    [-1, 0, 1].filter(conditions).should == [-1, 0]
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: filter
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-12-12 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &20615240 !ruby/object:Gem::Requirement
+  requirement: &13830380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *20615240
+  version_requirements: *13830380
 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
@@ -50,6 +50,17 @@ files:
 - Rakefile
 - filter.gemspec
 - lib/filter.rb
+- lib/filter/and.rb
+- lib/filter/condition.rb
+- lib/filter/matcher.rb
+- lib/filter/matchers/array.rb
+- lib/filter/matchers/base.rb
+- lib/filter/matchers/boolean.rb
+- lib/filter/matchers/class.rb
+- lib/filter/matchers/hash.rb
+- lib/filter/matchers/nil.rb
+- lib/filter/matchers/symbol.rb
+- lib/filter/or.rb
 - lib/filter/version.rb
 - spec/filter_spec.rb
 - spec/test_helper.rb