filter_fu 0.5.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+spec/debug.log

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Benedikt Deicke
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,75 @@
+= filter_fu
+
+This Ruby on Rails plugin adds a filtered_by method to your models. It accepts a hash of filters that are applied using named_scopes. In addition the plugin adds some view helpers to easily build filter forms.
+
+== Install
+
+You can install filter_fu as a gem or as a rails plugin.
+
+=== Install as gem
+
+Add this line to your <tt>config/environment.rb</tt> and run <tt>rake gems:install</tt>
+
+  config.gem 'filter_fu', :source => 'http://www.gemcutter.org'
+  
+=== Install as plugin
+
+Run this command in your currrent project's +RAILS_ROOT+
+
+  ./script/plugin install git://github.com/benedikt/filter_fu.git
+
+== Usage
+
+=== Models
+
+To enable filter_fu on a model, simply add one line to its definition:
+
+  class Project
+    filter_fu
+  end
+  
+Let's say you don't want your Projects list filtered by its +hidden+ column. You can easly
+tell filter_fu to ignore certian named scopes or columns:
+  
+  class Project
+    filter_fu :except => [:hidden]
+  end
+
+Of course this also works the other way round using the <tt>:only</tt> option to only allow filtering 
+for the given named scopes or columns:
+
+  class Project
+    filter_fu :only => [:starts_on, :ends_on]
+  end
+  
+Once you enabled filter_fu on your model it provides a filtered_by method.
+
+  Project.filtered_by(params[:filter])
+  Project.filtered_by(params[:filter]).some.named_scopes
+  Project.some.other.named_scopes.filtered_by(params[:filter])
+  
+
+=== Helper
+
+filter_fu comes with helpers to simplify the generation of filter forms:
+
+  <% filter_form do |f| %>
+    # f is a ActionView::Helpers::FormBuilder
+  <% end %>
+
+You can also specify a name for the filter (Default is <tt>:filter</tt>). This way you're able to have multiple filters on the same page.
+
+  <% filter_form_for(:product_filter) do |f| %>
+    # f is a ActionView::Helpers::FormBuilder
+  <% end %>  
+
+filter_fu will automatically include all other parameters for the current page (ie. pagination parameters) within the form. 
+If you wish to explicitly exclude some you can do this by passing an array as :ignore_parameters option.
+
+  <% filter_form_for(:product_filter, :ignore_parameters => [:page]) do |f| %>
+    # f is a ActionView::Helpers::FormBuilder
+  <% end %>
+
+== Copyright
+
+Copyright (c) 2009 Benedikt Deicke. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "filter_fu"
+    gem.summary = %Q{Filter ActiveRecord models using named_scopes}
+    gem.description = %Q{This Ruby on Rails plugin adds a filtered_by method to your models. It accepts a hash of filters that are applied using named_scopes. In addition the plugin adds some view helpers to easily build filter forms.}
+    gem.email = "benedikt@synatic.net"
+    gem.homepage = "http://github.com/benedikt/filter_fu"
+    gem.authors = ["Benedikt Deicke"]
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_opts = ['--options', 'spec/spec.opts']
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do 
+  Spec::Rake::SpecTask.new(:rcov) do |spec|
+    spec.libs << 'lib'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.rcov = true
+    spec.rcov_opts = ["--exclude", "^/,^spec/"]
+  end
+
+  Spec::Rake::SpecTask.new(:doc) do |spec|
+    spec.libs << 'lib' << 'spec'
+    spec.spec_opts = ["--color", "--format", "specdoc"]
+    spec.pattern = 'spec/**/*_spec.rb'
+  end
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "filter_fu #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('LICENSE*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/filter_fu.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{filter_fu}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Benedikt Deicke"]
+  s.date = %q{2009-10-15}
+  s.description = %q{This Ruby on Rails plugin adds a filtered_by method to your models. It accepts a hash of filters that are applied using named_scopes. In addition the plugin adds some view helpers to easily build filter forms.}
+  s.email = %q{benedikt@synatic.net}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "filter_fu.gemspec",
+     "lib/filter_fu.rb",
+     "lib/filter_fu/active_record.rb",
+     "lib/filter_fu/view_helper.rb",
+     "rails/init.rb",
+     "spec/active_record_spec.rb",
+     "spec/db/database.yml",
+     "spec/db/schema.rb",
+     "spec/dummies.rb",
+     "spec/filter_fu_spec.rb",
+     "spec/fixtures/employee.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/view_helper_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/benedikt/filter_fu}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Filter ActiveRecord models using named_scopes}
+  s.test_files = [
+    "spec/active_record_spec.rb",
+     "spec/db/schema.rb",
+     "spec/dummies.rb",
+     "spec/filter_fu_spec.rb",
+     "spec/fixtures/employee.rb",
+     "spec/spec_helper.rb",
+     "spec/view_helper_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/lib/filter_fu/active_record.rb

@@ -0,0 +1,62 @@
+module FilterFu
+  module ActiveRecord
+    
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      VALID_FILTER_OPTIONS = [:only, :except]
+      
+      def filter_fu(opts = {})
+        opts = opts.symbolize_keys!
+        opts.each_key { |option| raise "Invalid filter_fu option: #{option}" unless VALID_FILTER_OPTIONS.include?(option) }
+        raise "Use either :only or :except as a filter_fu option." if opts.has_key?(:only) && opts.has_key?(:except)
+        
+        opts[:only]   = [opts[:only]].flatten.collect(&:to_sym) if opts[:only]
+        opts[:except] = [opts[:except]].flatten.collect(&:to_sym) if opts[:except]
+        
+        @filter_options = opts
+        
+        extend SingletonMethods
+      end
+      
+    end
+    
+    module SingletonMethods
+      
+      def filtered_by(filter)
+        return scoped({}) if !filter || filter.empty?
+                
+        filter.inject(self) do |memo, (scope, arg)|
+          scope = scope.to_sym
+          next if protected?(scope)
+          if scopes.has_key?(scope)
+            memo.send(scope, arg)
+          else
+            memo.scoped(build_anonymous_scope(scope, arg))
+          end
+        end || scoped({})
+      end
+      
+      private
+      
+      def build_anonymous_scope(scope, arg)
+        return {} unless column_names.include?(scope.to_s) && !arg.blank?
+        { :conditions => { scope => arg } }
+      end
+      
+      def protected?(scope)
+        if @filter_options.has_key?(:only)
+          return !@filter_options[:only].include?(scope)
+        elsif @filter_options.has_key?(:except)
+          return @filter_options[:except].include?(scope)
+        end
+        return false
+      end
+      
+    end
+    
+  end
+end

data/lib/filter_fu/view_helper.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+module FilterFu
+  module ViewHelper
+    
+    def self.included(base) # :nodoc:
+      base.send :include, InstanceMethods
+    end
+    
+    module InstanceMethods
+      
+      def filter_form_for(*args, &block)
+        raise ArgumentError, 'Missing block' unless block_given?
+        
+        opts = args.extract_options!
+        name = (args.first || :filter).to_sym
+        
+        opts[:ignore_parameters] ||= []
+        opts[:ignore_parameters] += [:controller, :action, name]
+        
+        opts[:html] ||= {}
+        opts[:html][:method] ||= :get
+                
+        form_for(name, OpenStruct.new(params[name]), opts) do |f|
+          hidden_fields_for(params, opts)
+          block.call(f)
+        end
+      end
+      alias_method :filter_form, :filter_form_for
+      
+      private
+      
+      def hidden_fields_for(params, opts, prefix = nil)
+        params.each_pair do |k, v| 
+          next if opts[:ignore_parameters].include?(k.to_sym)
+          
+          k = "[#{k}]" if prefix
+          
+          if v.kind_of?(Hash)
+            hidden_fields_for(v, opts, "#{prefix}#{k}")
+          else 
+            concat(hidden_field_tag("#{prefix}#{k}", v)) 
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/filter_fu.rb

@@ -0,0 +1,4 @@
+%w(active_record view_helper).each { |file| require File.join(File.dirname(__FILE__), 'filter_fu', file) }
+
+ActiveRecord::Base.send :include, FilterFu::ActiveRecord
+ActionView::Base.send   :include, FilterFu::ViewHelper

data/rails/init.rb

@@ -0,0 +1 @@
+require 'filter_fu'

data/spec/active_record_spec.rb

@@ -0,0 +1,159 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/fixtures/employee')
+
+describe FilterFu::ActiveRecord do
+  
+  it "should add a filter_fu class method to ActiveRecord::Base" do
+    ActiveRecord::Base.should respond_to(:filter_fu)
+  end
+
+  describe "filter_fu" do
+    
+    it "should accept an options hash" do
+      lambda { ActiveRecord::Base.filter_fu({}) }.should_not raise_error(ArgumentError)
+    end
+    
+    it "should not require an options hash" do
+      lambda { ActiveRecord::Base.filter_fu }.should_not raise_error(ArgumentError)
+    end
+    
+    it "should add a new singleton method called filtered_by" do
+      Employee.should respond_to(:filtered_by)
+    end
+    
+    it "should not accept invalid options" do
+      lambda { ActiveRecord::Base.filter_fu(:invalid_option => 'some value') }.should raise_error
+    end
+    
+    %w(only except).each do |option|
+      it "should accept :#{option} as an option" do
+        lambda { ActiveRecord::Base.filter_fu(option => 'some value') }.should_not raise_error
+      end
+    end
+    
+    it "should not accept :except and :only option at the same time" do
+      lambda { ActiveRecord::Base.filter_fu(:only => 'some value', :except => 'some other value') }.should raise_error(/Use either :only or :except/)
+    end
+    
+  end
+  
+  describe "filtered_by" do
+    
+    before(:each) do
+      @plain_class = Class.new(Employee)
+      @class = @plain_class.clone
+      @class.filter_fu if @class.respond_to?(:filter_fu)
+    end
+    
+    it "should require a hash with filter params" do
+      lambda { @class.filtered_by }.should raise_error(ArgumentError)
+    end
+    
+    it "should not fail if the hash with filter params is nil" do
+      lambda { @class.filtered_by(nil) }.should_not raise_error(NoMethodError)
+    end
+    
+    it "should not filter anything if the hash is nil" do
+      @class.filtered_by(nil).should == @class.all
+    end
+    
+    it "should not filter anything if the hash is empty" do
+      @class.filtered_by({}).should == @class.all
+    end
+    
+    it "should not return nil if all scopes were skipped" do
+      # This is ugly. Is there a better solution to this?
+      klass = @plain_class.filter_fu :only => :salary
+      klass.filtered_by({ :country => 'Whatever' }).should_not be_nil
+    end
+    
+    it "should handle HashWithIndifferentAccess correctly" do
+      @class.filtered_by(HashWithIndifferentAccess.new('salary' => 100000)).should == @class.all(:conditions => 'salary = 100000')
+      @class.filtered_by(HashWithIndifferentAccess.new('boss' => true)).should == @class.all(:conditions => "position = 'Boss'")
+    end
+    
+    it "should return an instace of ActiveRecord::NamedScope::Scope" do      
+      @class.filtered_by({ :boss => nil }).class.should == ActiveRecord::NamedScope::Scope
+    end
+        
+    it "should call named scopes if specified in the filter params" do
+      @class.should_receive(:boss)
+      @class.filtered_by({ :boss => '' })
+    end
+    
+    it "should pass the value to the named scope" do
+      @class.should_receive(:country).with('some value')
+      @class.filtered_by({ :country => 'some value'})
+    end
+    
+    it "should only call the specified named scope if it is available" do
+      @class.should_not_receive(:unavailable)
+      @class.filtered_by({ :unavailable => '' })
+    end
+    
+    it "should allow multiple scopes at once and combine them" do
+      @class.filtered_by({ :position => 'Worker', :country => 'Country 1'}).should == @class.all(:conditions => { :position => 'Worker', :country => 'Country 1'})
+    end
+    
+    describe "when the given named scope is not available" do
+      
+      it "should create an anonymous scope using the filter options as conditions" do
+        @class.filtered_by(:salary => 100000).should == @class.all(:conditions => 'salary = 100000')
+      end
+    
+      it "should not create an anonymous scope if there is no column for it" do
+        lambda { @class.filtered_by(:non_existing_column => 'some value').all }.should_not raise_error(/no such column/)
+      end
+      
+      it "should not create an anonymous scope if the value is blank" do
+        @class.filtered_by(:salary => '').should == @class.all()
+      end
+      
+      it "should create an anonymous scope that is able to handle an array of possible values for the filter" do
+        @class.filtered_by(:salary => [80000, 90000]).should == @class.all(:conditions => 'salary IN (80000, 90000)')
+      end
+      
+    end
+
+    it "should not filter by scopes defined in :except option" do
+      klass = @plain_class.clone
+      klass.filter_fu :except => :dont_access_me
+      klass.named_scope :dont_access_me, {}
+      klass.named_scope :access_me, {}
+      
+      klass.should_not_receive(:dont_access_me)
+      klass.filtered_by(:dont_access_me => '')
+    end
+    
+    it "should filter by scopes not defined in :except option" do
+      klass = @plain_class.clone
+      klass.filter_fu :except => :dont_access_me
+      klass.named_scope :dont_access_me, {}
+      klass.named_scope :access_me, {}
+      
+      klass.should_receive(:access_me)
+      klass.filtered_by(:access_me => '')
+    end
+    
+    it "should only filter by scopes define in :only option" do
+      klass = @plain_class.clone
+      klass.filter_fu :only => :only_access_me
+      klass.named_scope :only_access_me, {}
+      klass.named_scope :dont_access_me, {}
+      
+      klass.should_receive(:only_access_me)
+      klass.filtered_by(:only_access_me => '')
+    end
+    
+    it "should not filter by scopes not defined in :only option" do
+      klass = @plain_class.clone
+      klass.filter_fu :only => :only_access_me
+      klass.named_scope :only_access_me, {}
+      klass.named_scope :dont_access_me, {}
+      
+      klass.should_not_receive(:dont_access_me)
+      klass.filtered_by(:dont_access_me => '')
+    end
+  end
+  
+end

data/spec/db/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  database: ":memory:"
+  adapter: sqlite3

data/spec/db/schema.rb

@@ -0,0 +1,10 @@
+ActiveRecord::Schema.define(:version => 0) do
+
+  create_table :employees, :force => true do |t|
+    t.string  :name
+    t.string  :country
+    t.string  :position
+    t.integer :salary
+  end
+  
+end

data/spec/dummies.rb

@@ -0,0 +1,46 @@
+# Taken from mislav's will_paginate http://github.com/mislav/will_paginate/tree/master
+
+class DummyRequest
+  attr_accessor :symbolized_path_parameters
+  
+  def initialize
+    @get = true
+    @params = {}
+    @symbolized_path_parameters = { :controller => 'foo', :action => 'bar' }
+  end
+  
+  def get?
+    @get
+  end
+
+  def post
+    @get = false
+  end
+
+  def relative_url_root
+    ''
+  end
+
+  def params(more = nil)
+    @params.update(more) if more
+    @params
+  end
+end
+
+class DummyController
+  attr_reader :request
+  attr_accessor :controller_name
+  
+  def initialize
+    @request = DummyRequest.new
+    @url = ActionController::UrlRewriter.new(@request, @request.params)
+  end
+
+  def params
+    @request.params
+  end
+  
+  def url_for(params)
+    @url.rewrite(params)
+  end
+end

data/spec/filter_fu_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe FilterFu do
+  
+  it "should include FilterFu::ViewHelper into ActionView::Base" do
+    ActionView::Base.ancestors.should include(FilterFu::ViewHelper)
+  end
+  
+  it "should include FilterFu::ActiveRecord into ActiveRecord::Base" do
+    ActiveRecord::Base.ancestors.should include(FilterFu::ActiveRecord)
+  end
+  
+end

data/spec/fixtures/employee.rb

@@ -0,0 +1,14 @@
+class Employee < ActiveRecord::Base
+  
+  named_scope :boss, :conditions => "position = 'Boss'"
+  named_scope :country, lambda { |country| { :conditions => ["country = ?", country] } }
+
+end
+
+20.times do |n|
+  position  = (n == 0) ? "Boss" : "Worker"
+  salary    = (n == 0) ? 100000 : (((n+1) % 5) * 10000)
+  Employee.create(:name => "Employee #{n}", :country => "Country #{(n % 10) + 1}", :position => position, :salary => salary)
+end
+
+#puts Employee.all.inspect

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+begin
+  require File.dirname(__FILE__) + '/../../../../spec/spec_helper'
+rescue LoadError
+  puts "You need to install rspec in your base app"
+  exit
+end
+
+require 'filter_fu'
+
+Spec::Runner.configure do |config|
+
+end
+
+ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), 'debug.log'))
+
+configuration = YAML.load_file(File.join(File.dirname(__FILE__), 'db', 'database.yml'))
+ActiveRecord::Base.establish_connection(configuration[ENV["DB"] || "sqlite3"])
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  load(File.join(File.dirname(__FILE__), "db", "schema.rb"))
+end

data/spec/view_helper_spec.rb

@@ -0,0 +1,127 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'dummies'
+
+describe FilterFu::ViewHelper, :type => :helper do
+  
+  before(:each) do
+    @controller  = DummyController.new
+    @request     = @controller.request
+    
+    helper.controller = @controller
+    helper.request = @request
+    
+    helper.output_buffer = ""
+  end
+
+  it "should provide a filter_form_for method" do
+    helper.should respond_to(:filter_form_for)
+  end
+  
+  it "should prodive a filter_form method as an alias for filter_form" do
+    helper.should respond_to(:filter_form)
+  end
+  
+  it "should require a block" do
+    lambda { helper.filter_form_for }.should raise_error(ArgumentError, /Missing block/)
+  end
+  
+  it "should accept options" do
+    lambda { helper.filter_form_for({}) {} }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should not require options" do
+    lambda { helper.filter_form_for() {} }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should accept a name together with options" do
+    lambda { helper.filter_form_for(:other, {}) {} }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should call the associated block" do
+    lambda {
+      helper.filter_form_for() { throw :done }
+    }.should throw_symbol(:done)
+  end
+  
+  it "should pass a ActionView::Helpers::FormBuilder to the block" do
+    helper.filter_form_for { |f| f.should be_kind_of(ActionView::Helpers::FormBuilder) }
+  end
+  
+  it "should include the erb of the block" do
+    html = eval_erb("<% filter_form_for { %><div>Some random HTML</div><% } %>")
+    html.should have_tag('div', 'Some random HTML')
+  end
+  
+  it "should include a form tag" do
+    html = eval_erb("<% filter_form_for { %> <% } %>")
+    html.should have_tag('form')
+  end
+  
+  it "should set the form method attribute to GET" do
+    html = eval_erb("<% filter_form_for { %> <% } %>")  
+    html.should have_tag('form[method=?]', 'get')
+  end
+  
+  it "should set the form action attribute to the current url" do
+    # Controller and Action are foo and bar as defined in the dummies
+    html = eval_erb("<% filter_form_for { %> <% } %>")  
+    html.should have_tag('form[action=?]', '/foo/bar')
+  end
+  
+  it "should use :filter as the default namespace in form fields" do
+    html = eval_erb("<% filter_form_for { |f| %><%= f.text_field :name %><% } %>")
+    html.should have_tag('input[name=?]', 'filter[name]')
+  end
+  
+  it "should use another name as namespace if it's provided as the first argument" do
+    html = eval_erb("<% filter_form_for(:other) { |f| %><%= f.text_field :name %><% } %>")
+    html.should have_tag('input[name=?]', 'other[name]')
+  end
+  
+  it "should pass options to the form_for helper" do
+    html = eval_erb("<% filter_form_for(:html => { :class => 'filter' }) { |f| %> <% } %>")
+    html.should have_tag('form[class=?]', 'filter')
+  end
+  
+  it "should preserve the page's parameters with hidden fields" do
+    helper.params = { :some_param => 'some value', :some_other_param => 'some other value' }
+    html = eval_erb("<% filter_form_for() { |f| %> <% } %>")
+    html.should have_tag('input[type=?][name=?][value=?]', 'hidden', 'some_param', 'some value')
+    html.should have_tag('input[type=?][name=?][value=?]', 'hidden', 'some_other_param', 'some other value')
+  end
+  
+  it "should preserve the page's nested parameters with hidden fields" do
+    helper.params = { :some_param => 'some value', :nested => { :some_other_param => 'some other value', :deeply_nested => { :down_here => 'yet another value' } } }
+    html = eval_erb("<% filter_form_for() { |f| %> <% } %>")
+    html.should have_tag('input[type=?][name=?][value=?]', 'hidden', 'some_param', 'some value')
+    html.should have_tag('input[type=?][name=?][value=?]', 'hidden', 'nested[some_other_param]', 'some other value')
+    html.should have_tag('input[type=?][name=?][value=?]', 'hidden', 'nested[deeply_nested][down_here]', 'yet another value')
+  end
+  
+  it "should not preserve the page's parameters for the current filter" do
+    helper.params = { :other => { :name => 'some value' }}
+    html = eval_erb("<% filter_form_for(:other) { |f| %> <% } %>")
+    html.should_not have_tag('input[type=?][name=?]', 'hidden', 'other')
+    html.should_not have_tag('input[type=?][name=?][value=?]', 'hidden', 'other[name]', 'some value')
+  end
+  
+  it "should not preserve the controller and action params" do
+    helper.params = { :controller => 'foo', :action => 'bar' }
+    html = eval_erb("<% filter_form_for() { |f| %> <% } %>")
+    html.should_not have_tag('input[type=?][name=?][value=?]', 'hidden', 'controller', 'foo')
+    html.should_not have_tag('input[type=?][name=?][value=?]', 'hidden', 'action', 'bar')
+  end
+  
+  it "should not preserve params specified in :ignore_parameters" do
+    helper.params = { :some_param => 'some value', :some_other_param => 'some other value' }
+    html = eval_erb("<% filter_form_for(:ignore_parameters => [:some_other_param]) { |f| %> <% } %>")
+    html.should have_tag('input[type=?][name=?][value=?]', 'hidden', 'some_param', 'some value')
+    html.should_not have_tag('input[type=?][name=?][value=?]', 'hidden', 'some_other_param', 'some other value')
+  end
+  
+  it "should use the current filter params as defaults for the form" do
+    helper.params = { :filter => { :some_param => 'some value' } }
+    html = eval_erb("<% filter_form_for() { |f| %><%= f.text_field :some_param %><% } %>")
+    html.should have_tag('input[type=?][name=?][value=?]', 'text', 'filter[some_param]', 'some value')
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: filter_fu
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Benedikt Deicke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-15 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: This Ruby on Rails plugin adds a filtered_by method to your models. It accepts a hash of filters that are applied using named_scopes. In addition the plugin adds some view helpers to easily build filter forms.
+email: benedikt@synatic.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- filter_fu.gemspec
+- lib/filter_fu.rb
+- lib/filter_fu/active_record.rb
+- lib/filter_fu/view_helper.rb
+- rails/init.rb
+- spec/active_record_spec.rb
+- spec/db/database.yml
+- spec/db/schema.rb
+- spec/dummies.rb
+- spec/filter_fu_spec.rb
+- spec/fixtures/employee.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/view_helper_spec.rb
+has_rdoc: true
+homepage: http://github.com/benedikt/filter_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Filter ActiveRecord models using named_scopes
+test_files: 
+- spec/active_record_spec.rb
+- spec/db/schema.rb
+- spec/dummies.rb
+- spec/filter_fu_spec.rb
+- spec/fixtures/employee.rb
+- spec/spec_helper.rb
+- spec/view_helper_spec.rb