filtration 0.0.1 → 0.0.2

data/README.rdoc

@@ -15,7 +15,16 @@ Example:
   class Foo < Bar
     prefilter(:foo){|x| x * 2}        # (x * 2) + 2
     postfilter(:foo_too){|x| x * 2}   # (x + 2) * 2
-  end 
+  end
+
+  class AnotherFoo < Bar
+    prefilter :foo, :double           # (x * 2) + 2
+    postfilter :foo_too, :double      # (x + 2) * 2
+    
+    def double(x)
+      x * 2
+    end
+  end
 
 == Requirements
 Filtration stands on its own!

data/lib/filtration.rb

@@ -1,18 +1,38 @@
 module Filtration
 
-  def prefilter(method,&block)
+  def prefilter(method, filter=nil, &block)
     old_method = instance_method(method)
     raise "Method #{method} takes 0 arguments" if old_method.arity == 0
+
+    raise "Cannot use both filter method and block" if !filter.nil? && !block.nil?
+    raise "Block or filter method missing" if filter.nil? && block.nil?
+
     define_method(method) do |*args|
-      old_method.bind(self).call(block.call(*args))
+      if filter.nil?
+        old_method.bind(self).call(block.call(*args))
+      else
+        filter_method = method(filter)
+        raise "Filter method #{filter} takes 0 arguments" if filter_method.arity == 0
+        old_method.bind(self).call(self.send(filter,*args))
+      end
     end
   end
 
-  def postfilter(method,&block)
+  def postfilter(method, filter=nil, &block)
     old_method = instance_method(method)
     raise "Method #{method} takes 0 arguments" if old_method.arity == 0
+
+    raise "Cannot use both filter method and block" if !filter.nil? && !block.nil?
+    raise "Block or filter method missing" if filter.nil? && block.nil?
+
     define_method(method) do |*args|
-      block.call(old_method.bind(self).call(*args))
+      if filter.nil?
+        block.call(old_method.bind(self).call(*args))
+      else
+        filter_method = method(filter)
+        raise "Filter method #{filter} takes 0 arguments" if filter_method.arity == 0
+        self.send(filter,old_method.bind(self).call(*args))
+      end
     end
   end
 

data/spec/filtration_spec.rb

@@ -1,40 +1,87 @@
 require 'spec_helper'
 
+class Good
+  def foo(x)
+    x + 2
+  end
+end
+
+class Bad
+  def foo
+    2
+  end
+end
+
 describe Filtration do
 
   it 'executes a code block before the specified method' do
-    class Foo1
-      def foo(x)
-        x + 2
-      end
-    end
-    class Test1 < Foo1
+    class Test1 < Good 
       prefilter(:foo){|x| x * 2}
     end
     Test1.new.foo(2).should === 6
   end
 
   it 'executes a code block after the specified method' do
-    class Foo2
-      def foo(x)
-        x + 2
+    class Test2 < Good
+      postfilter(:foo){|x| x * 2}
+    end
+    Test2.new.foo(2).should === 8
+  end
+
+  it 'executes a code block before the specified method' do
+    class Test3 < Good 
+      prefilter :foo, :bar
+      def bar(x)
+        x * 2
       end
     end
-    class Test2 < Foo2
-      postfilter(:foo){|x| x * 2}
+    Test1.new.foo(2).should === 6
+  end
+
+  it 'executes a code block after the specified method' do
+    class Test4 < Good
+      postfilter :foo, :bar
+      def bar(x)
+        x * 2
+      end
     end
     Test2.new.foo(2).should === 8
   end
 
   it 'raises an error if the method has no arguments' do
-    class Foo3
-      def foo
-        2
+    class Test5 < Bad
+      extend RSpec::Matchers
+      lambda { prefilter(:foo){|x| x * 2} }.should raise_error
+    end
+  end
+
+  it 'raises an error if the filter method has no arguments' do
+    class Test6 < Good
+      prefilter :foo, :bar
+      def bar
+        nil
+      end
+    end
+    lambda { Test6.new.foo(2) }.should raise_error
+  end
+
+  it 'raises an error if both filter and block are specified' do
+    class Test7 < Good
+      extend RSpec::Matchers
+      def bar(x)
+        x * 2
       end
+      lambda { prefilter(:foo,:bar){|x| x * 2} }.should raise_error
     end
-    class Test3 < Foo3
+  end
+
+  it 'raises an error if neither filter nor block are specified' do
+    class Test8 < Good
       extend RSpec::Matchers
-      lambda { prefilter(:foo){|x| x * 2} }.should raise_error
+      def bar(x)
+        x * 2
+      end
+      lambda { prefilter(:foo) }.should raise_error
     end
   end
 

metadata

@@ -2,7 +2,7 @@
 name: filtration
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - R. Scott Reis
@@ -35,7 +35,7 @@ rdoc_options:
 - -m
 - README.rdoc
 - -t
-- Anemone
+- Filtration
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement