filtration 0.0.2 → 0.0.3

data/README.rdoc

@@ -1,33 +1,64 @@
 = Filtration
-Filtration is a clean, lightweight way to filter arguments going into and out of methods.
+Filtration is a clean, lightweight way to filter arguments going into and coming out of methods (similar to decorators in Python).
 
 == Usage
 Example:
   class Bar
+  
     def foo(x)
       x + 2
     end
+    
     def foo_too(x)
       x + 2
     end
+    
+    def foo_as_well(x)
+      "#{x.to_s} to the max!"
+    end
+    
+    def foo_forever(x)
+      "#{x.to_s} to the max!"
+    end
+  
   end
   
   class Foo < Bar
-    prefilter(:foo){|x| x * 2}        # (x * 2) + 2
-    postfilter(:foo_too){|x| x * 2}   # (x + 2) * 2
+    
+    prefilter(:foo){|x| x * 2}
+    #=> (x * 2) + 2 = 6 (for x = 2)
+    
+    postfilter(:foo_too){|x| x * 2}
+    #=> (x + 2) * 2 = 8 (for x = 2)
+  
   end
-
+  
   class AnotherFoo < Bar
-    prefilter :foo, :double           # (x * 2) + 2
-    postfilter :foo_too, :double      # (x + 2) * 2
+    
+    prefilter :foo, :double
+    #=> (x * 2) + 2 = 6 (for x = 2)
+    
+    postfilter :foo_too, :double
+    #=> (x + 2) * 2 => 8 (for x = 2)
     
     def double(x)
       x * 2
     end
+  
+  end
+  
+  class YetAnotherFoo < Bar
+    
+    prefilter :foo_as_well, &:upcase
+    #=> "#{x.upcase} to the max!" = 'FILTRATION to the max!' (for x = 'filtration')
+    
+    postfilter :foo_forever, &:upcase
+    #=> "#{x} to the max!".upcase = 'FILTRATION TO THE MAX!' (for x = 'filtration')
+    
   end
 
 == Requirements
 Filtration stands on its own!
 
 == Development
-RSpec is used for testing.
+RSpec is used for testing, with SimpleCov for code coverage.

data/spec/filtration_spec.rb

@@ -1,88 +1,141 @@
 require 'spec_helper'
 
-class Good
-  def foo(x)
-    x + 2
-  end
-end
+describe Filtration do
 
-class Bad
-  def foo
-    2
-  end
-end
+  describe '#prefilter' do
 
-describe Filtration do
+    context 'given a valid target method' do
 
-  it 'executes a code block before the specified method' do
-    class Test1 < Good 
-      prefilter(:foo){|x| x * 2}
-    end
-    Test1.new.foo(2).should === 6
-  end
+      context 'and a code block for filtering' do
+        it 'executes the block on the target method argument' do
+          test = Class.new(Good) { prefilter(:foo){|x| x * 2} }
+          test.new.foo(2).should === 6
+        end
+      end
 
-  it 'executes a code block after the specified method' do
-    class Test2 < Good
-      postfilter(:foo){|x| x * 2}
-    end
-    Test2.new.foo(2).should === 8
-  end
+      context 'and a valid filter method' do
+        it 'executes the filter method on the target method argument' do
+          test = Class.new(Good) do
+            prefilter :foo, :double
+            def double(x) x * 2; end
+          end
+          test.new.foo(2).should === 6
+        end
+      end
 
-  it 'executes a code block before the specified method' do
-    class Test3 < Good 
-      prefilter :foo, :bar
-      def bar(x)
-        x * 2
+      context 'and an invalid filter method' do
+        it 'raises an error' do
+          test = Class.new(Good) do
+            prefilter :foo, :double
+            def double() 2; end
+          end
+          expect { test.new.foo(2) }.to raise_error
+        end
       end
+
     end
-    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
+    context 'given an invalid target method' do
+
+      context 'and a code block for filtering' do
+        it 'raises an error' do
+          Class.new(Bad) do
+            extend RSpec::Matchers
+            expect { prefilter(:foo){|x| x * 2} }.to raise_error
+          end
+        end
       end
-    end
-    Test2.new.foo(2).should === 8
-  end
 
-  it 'raises an error if the method has no arguments' do
-    class Test5 < Bad
-      extend RSpec::Matchers
-      lambda { prefilter(:foo){|x| x * 2} }.should raise_error
-    end
-  end
+      context 'and a valid filter method' do
+        it 'raises an error' do
+          test = Class.new(Good) do
+            prefilter :foo, :double
+            def double(x) x * 2; end
+          end
+          expect { test.new.foo }.to 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
+      context 'and an invalid filter method' do
+        it 'raises an error' do
+          test = Class.new(Good) do
+            prefilter :foo, :double
+            def double() 2; end
+          end
+          expect { test.new.foo }.to raise_error
+        end
       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
+  describe '#postfilter' do
+
+    context 'given a valid target method' do
+
+      context 'and a code block for filtering' do
+        it 'executes the block on the target method argument' do
+          test = Class.new(Good) { postfilter(:foo){|x| x * 2} }
+          test.new.foo(2).should === 8
+        end
       end
-      lambda { prefilter(:foo,:bar){|x| x * 2} }.should raise_error
+
+      context 'and a valid filter method' do
+        it 'executes the filter method on the target method argument' do
+          test = Class.new(Good) do
+            postfilter :foo, :double
+            def double(x) x * 2; end
+          end
+          test.new.foo(2).should === 8
+        end
+      end
+
+      context 'and an invalid filter method' do
+        it 'raises an error' do
+          test = Class.new(Good) do
+            postfilter :foo, :double
+            def double() 2; end
+          end
+          expect { test.new.foo(2) }.to raise_error
+        end
+      end
+
     end
-  end
 
-  it 'raises an error if neither filter nor block are specified' do
-    class Test8 < Good
-      extend RSpec::Matchers
-      def bar(x)
-        x * 2
+    context 'given an invalid target method' do
+
+      context 'and a code block for filtering' do
+        it 'raises an error' do
+          Class.new(Bad) do
+            extend RSpec::Matchers
+            expect { postfilter(:foo){|x| x * 2} }.to raise_error
+          end
+        end
+      end
+
+      context 'and a valid filter method' do
+        it 'raises an error' do
+          test = Class.new(Good) do
+            postfilter :foo, :double
+            def double(x) x * 2; end
+          end
+          expect { test.new.foo }.to raise_error
+        end
       end
-      lambda { prefilter(:foo) }.should raise_error
+
+      context 'and an invalid filter method' do
+        it 'raises an error' do
+          test = Class.new(Good) do
+            postfilter :foo, :double
+            def double() 2; end
+          end
+          expect { test.new.foo }.to raise_error
+        end
+      end
+
     end
+
   end
 
 end

data/spec/spec_dummies.rb

@@ -0,0 +1,11 @@
+class Good
+  def foo(x)
+    x + 2
+  end
+end
+
+class Bad
+  def foo
+    2
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,11 @@
+require 'simplecov'
+SimpleCov.start { add_filter '/spec/' }
+
 $:.unshift(File.dirname(__FILE__) + '/../lib/')
 
-require 'rspec'
-require 'filtration'
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default,:test)
+
+require 'filtration'
+require 'spec_dummies'

metadata

@@ -2,7 +2,7 @@
 name: filtration
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - R. Scott Reis
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-12 00:00:00 Z
+date: 2011-04-15 00:00:00 Z
 dependencies: []
 
 description: 
@@ -26,6 +26,7 @@ files:
 - README.rdoc
 - lib/filtration.rb
 - spec/spec_helper.rb
+- spec/spec_dummies.rb
 - spec/filtration_spec.rb
 homepage: 
 licenses: []
@@ -56,7 +57,8 @@ rubyforge_project:
 rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
-summary: Filtration pre/post method callback
+summary: Filtration enables pre/post method callback, similar to Python decorators
 test_files: 
 - spec/spec_helper.rb
+- spec/spec_dummies.rb
 - spec/filtration_spec.rb