filter_object 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+bin

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in filter_object.gemspec
+gemspec

data/README.md

@@ -0,0 +1,106 @@
+## TL;DR
+``` ruby
+class YourController < ApplicationController
+  before_filter YourFilterClass.new
+end
+
+# Inside app/filters/your_filter_class.rb
+class YourFilterClass
+  include FilterObject::Filter
+
+  def filter(controller)
+    super
+     # your filter logic starts here...
+  end
+end
+```
+
+## What's a Filter Object?
+
+A filter object is a nice way to remove logic from your controller. Usually you start implementing simple filter methods, like these
+
+``` ruby
+class YourController < ApplicationController
+  before_filter :your_filter_method
+
+  # your actions...
+
+  private
+  def your_filter_method
+    # some simple logic here...
+  end
+end
+```
+
+and everything is fine. As the time passes you start to add more code to the `your_filter_method` filter method. It will look like shit after some time... 
+
+Sometimes the problem already starts too complicated for a single method. 
+
+Rails already provides a way to fix this kind of problem. You can do something like this:
+
+``` ruby
+class YourController < ApplicationController
+  before_filter FilterClass
+
+  # your actions...
+end
+
+class FilterClass
+  def self.filter(controller)
+    # your complex filter logic goes here...
+  end
+end
+```
+
+and it will work. Only that now you are creating a lot of class methods, which are hard to test. Also, it's hard to keep state inside your filter. The nice thing is that you can easily pass anything that responds to `filter` to the before_filter and after_filter calls. So why not pass an instance?
+
+``` ruby
+class YourController < ApplicationController
+  before_filter FilterClass.new
+
+  # your actions...
+end
+
+class FilterClass
+  def filter(controller)
+    # your complex filter logic goes here...
+  end
+end
+```
+
+Ok, now this is real OO! It will much easier to write your tests, too. But you'll need to handle methods delegation to the controller, things like calling `params`, `render`, and so on. 
+
+This is where filter_object comes in.
+
+``` ruby
+class FilterClass
+  include FilterObject::Filter
+
+  def filter(controller)
+    super # so filter_object can set the delegations
+    
+    if params[:programming_is] != "cool" # the call to params will be automatically redirected to the controller
+      redirect_to program_more_path
+    end
+  end
+end
+```
+
+Now you can call controller methods directly inside your filter objects and they will be properly delegated to the controller. 
+
+#### Methods that will be automatically delegated to the controller
+* params
+* flash
+* render
+* redirect_to
+* cookies
+* session
+* headers
+* request
+
+If you are using a controller method that is not listed here, please send a pull request!
+
+## Why a gem for such a simple and stupid code?
+
+Because I was repeating this thing all over my projects, so I got tired.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/filter_object.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "filter_object/version"
+
+Gem::Specification.new do |s|
+  s.name        = "filter_object"
+  s.version     = FilterObject::VERSION
+  s.authors     = ["Cássio Marques"]
+  s.email       = ["cassiommc@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Create objects to handle filter logic and clean up your controllers}
+  s.description = %q{You can use filter_object to write classes whose instances encapsulate your filter logic, so you can have testable code and cleaner controllers}
+
+  s.rubyforge_project = "filter_object"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/filter_object.rb

@@ -0,0 +1,16 @@
+require "filter_object/version"
+require "forwardable"
+
+module FilterObject
+  module Filter
+    extend Forwardable
+
+    def_delegators :@controller, :params, :request, :flash, :redirect_to, :render, :session, :headers, :cookies
+
+    attr_reader :controller
+
+    def filter(controller)
+      @controller = controller
+    end
+  end
+end

data/lib/filter_object/version.rb

@@ -0,0 +1,3 @@
+module FilterObject
+  VERSION = "0.0.1"
+end

data/spec/filter_object_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe FilterObject::Filter do
+  class FilterObjectTestClass
+    include FilterObject::Filter
+  end
+
+  subject { FilterObjectTestClass.new }
+
+  let(:controller) { stub }
+
+  it { should respond_to(:filter) }
+
+  describe "#filter" do
+    let(:filter_object) { FilterObjectTestClass.new }
+
+    def run_filter
+      filter_object.filter controller
+    end
+
+    it "configures the filter's controller" do
+      expect { filter_object.filter controller }.to change { filter_object.controller }.to controller
+    end
+
+    context "#params delegation" do
+      before do
+        def filter_object.filter(controller)
+          super
+          params
+        end
+      end
+
+      it "delegates calls to #params to the controller" do
+        controller.should_receive(:params)
+        run_filter
+      end
+    end
+
+    context "#request delegation" do
+      before do
+        def filter_object.filter(controller)  
+          super
+          request
+        end
+      end
+
+      it "delegates calls to #request to the controller" do
+        controller.should_receive(:request)
+        run_filter
+      end
+    end
+
+    context "#flash delegation" do
+      before do
+        def filter_object.filter(controller)
+          super
+          flash
+        end
+      end
+
+      it "delegates calls to #flash to the controller" do
+        controller.should_receive(:flash)
+        run_filter
+      end
+    end
+
+    context "#redirect_to delegation" do
+      before do
+        def filter_object.filter(controller)
+          super
+          redirect_to
+        end
+      end
+
+      it "delegates calls to #redirect_to to the controller" do
+        controller.should_receive(:redirect_to)
+        run_filter
+      end
+    end
+
+    context "#render delegation" do
+      before do
+        def filter_object.filter(controller)  
+          super
+          render
+        end
+      end
+
+      it "delegates calls to #render to the controller" do
+        controller.should_receive(:render)
+        run_filter
+      end
+    end
+
+    context "#session delegation" do
+      before do
+        def filter_object.filter(controller)
+          super
+          session
+        end
+      end
+
+      it "delegates calls to #session to the controller" do
+        controller.should_receive(:session)
+        run_filter
+      end
+    end
+
+    context "#headers delegation" do
+      before do
+        def filter_object.filter(controller)
+          super
+          headers
+        end
+      end
+
+      it "delegates calls to #headers to the controller" do
+        controller.should_receive(:headers)
+        run_filter
+      end
+    end
+
+    context "#cookies delegation" do
+      before do
+        def filter_object.filter(controller)
+          super
+          cookies
+        end
+      end
+
+      it "delegates calls to #cookies to the controller" do
+        controller.should_receive(:cookies)
+        run_filter
+      end
+    end
+
+    context "calling undefined methods" do
+      before do
+        def filter_object.filter(controller)
+          super 
+          whatever
+        end
+      end
+
+      it "does not delegate calls to unknown methods" do
+        expect { run_filter }.to raise_error(NameError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require "filter_object"
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: filter_object
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Cássio Marques
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2160672660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160672660
+description: You can use filter_object to write classes whose instances encapsulate
+  your filter logic, so you can have testable code and cleaner controllers
+email:
+- cassiommc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- filter_object.gemspec
+- lib/filter_object.rb
+- lib/filter_object/version.rb
+- spec/filter_object_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: filter_object
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Create objects to handle filter logic and clean up your controllers
+test_files:
+- spec/filter_object_spec.rb
+- spec/spec_helper.rb
+has_rdoc: