smart_filters 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Rizwan Reza
+
+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.md

@@ -0,0 +1,6 @@
+Smart Filters
+=============
+
+Smart Filters is an implementation of what you see in the Smart Playlist dialog in iTunes but using ActiveRecord model as the table and columns as the data. It is wise enough to select different criteria based on the column type. 
+
+Copyright (c) 2010 Rizwan Reza for Monaqasat, released under the MIT license.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+desc 'Generate documentation for the smart_filters plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SmartFilters'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+PKG_FILES = FileList[
+  '[a-zA-Z]*',
+  'app/**/*',
+  'lib/**/*',
+  'rails/**/*',
+  'spec/**/*'
+]
+
+spec = Gem::Specification.new do |s|
+  s.name = "smart_filters"
+  s.version = "0.0.1"
+  s.author = "Rizwan Reza"
+  s.email = "contact@rizwanreza.com"
+  s.homepage = "http://github.com/Monaqasat/smart_filters"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Quickly create smart filters for any ActiveRecord model."
+  s.files = PKG_FILES.to_a
+  s.description = "Smart Filters is an implementation of what you see in the Smart Playlist dialog in iTunes but using ActiveRecord model as the table and columns as the data. It is wise enough to select different criteria based on the column type."
+  s.require_path = "lib"
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README.md"]
+end
+
+desc 'Turn this plugin into a gem.'
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end

data/app/views/shared/_filtered_results.html.erb

@@ -0,0 +1,15 @@
+<table>
+  <tr>
+    <% @filtered_results.first.attributes.each do |column, value| %>
+      <th><%= column.humanize %></th>
+    <% end %>
+  </tr>
+
+  <% @filtered_results.each do |record| %>
+    <tr>
+      <% record.attributes.each do |attribute, value| %>
+        <td><%=h value %></td>
+      <% end %>
+    </tr>
+  <% end %>
+</table>

data/lib/smart_filters/before_filter.rb

@@ -0,0 +1,11 @@
+def sort_smart_filter
+  if params[:smart_filter]
+    search = params[:smart_filter]
+    hash = {}
+    search.delete_if {|column, value| value[:value] == "" }
+    search.each do |column, value|
+      hash.merge!({column.to_sym => {value[:criteria] => value[:value]}})
+    end
+    @filtered_results = params[:smart_filter][:model].constantize.smart_filter(hash)
+  end
+end

data/lib/smart_filters/smart_filter.rb

@@ -0,0 +1,80 @@
+module SmartFilter
+  def smart_filter(options)
+    @conds = []
+    columns.each do |column|
+      if options[column.name.to_sym]
+        case options[column.name.to_sym].keys.first
+        when "contains"         then @conds << contains(column.name, options[column.name.to_sym]["contains"])
+        when "does_not_contain" then @conds << does_not_contain(column.name, options[column.name.to_sym]["does_not_contain"])
+        when "is"               then @conds << is(column.name, options[column.name.to_sym]["is"])
+        when "starts_with"      then @conds << starts_with(column.name, options[column.name.to_sym]["starts_with"])
+        when "ends_with"        then @conds << ends_with(column.name, options[column.name.to_sym]["ends_with"])
+        when "equals_to"        then @conds << equals_to(column.name, options[column.name.to_sym]["equals_to"])
+        when "greater_than"     then @conds << greater_than(column.name, options[column.name.to_sym]["greater_than"])
+        when "less_than"        then @conds << less_than(column.name, options[column.name.to_sym]["less_than"])
+        when "between"          then @conds << between(column.name, 
+                                                      options[column.name.to_sym]["between"].first, 
+                                                      options[column.name.to_sym]["between"].last)
+        else
+          return []
+        end
+      end
+    end
+    return find(:all, 
+                :conditions => conditions)
+  end
+
+  private
+
+  def conditions
+    @conds.flatten!
+    @final = []
+    @terms = []
+    @conds.each_with_index do |condition, index|
+      if (index + 1) % 2 == 0
+        if condition.is_a?(Hash)
+          @terms << condition.to_a.flatten
+        else
+          @terms << condition
+        end
+      elsif (index + 1) % 2 != 0
+        @final << condition
+      end
+    end
+    return [@final.join(' AND '), @terms].flatten
+  end
+
+  def contains(column, term)
+    ["#{column} LIKE ?", "%#{term}%"]
+  end
+
+  def does_not_contain(column, term)
+    ["#{column} NOT LIKE ?", "%#{term}%"]
+  end
+
+  def between(column, start, finish)
+    ["#{column} BETWEEN ? AND ?", {start => finish}]
+  end
+
+  def is(column, term)
+    ["#{column} = ?", term]
+  end
+
+  def starts_with(column, term)
+    ["#{column} LIKE ?", "#{term}%"]
+  end
+
+  def ends_with(column, term)
+    ["#{column} LIKE ?", "%#{term}"]
+  end
+
+  alias :equals_to :is
+
+  def greater_than(column, term)
+    ["#{column} > ?", term]
+  end
+
+  def less_than(column, term)
+    ["#{column} < ?", term]
+  end
+end

data/lib/smart_filters/view_helpers.rb

@@ -0,0 +1,55 @@
+module ViewHelpers
+  def smart_filter(model, cols, &block)
+    body = capture(&block)
+    html = ""
+    html << "<form action='/address_books' method='get'>"
+    html << "<input type='hidden' name='smart_filter[model]' value='#{model}'>"
+    columns(model, cols).each do |column|
+      
+      html << content_tag(:label, column.capitalize, :for => "#{column}")
+      html << content_tag(:select, :name => "smart_filter[#{column}][criteria]", :id => "name-criteria") do
+        criteria_options(model, column)
+      end
+      html <<  tag("input", { :type => 'text', :name => "smart_filter[#{column}][value]", :placeholder => "String" })
+      html << '<br>'
+    end
+    html << "<input type='submit'>"
+    html << "</form>"
+    html << render(:partial => 'shared/filtered_results') if @filtered_results
+    html << body unless @filtered_results
+    concat html
+  end
+
+  private
+
+  def columns(model, cols)
+    if cols == :all
+      all_cols = model.column_names
+      all_cols.delete("id")
+      all_cols
+    else
+      cols
+    end
+  end
+
+  def criteria_options(model, column)
+    if model.columns_hash[column].type == :string or model.columns_hash[column].type == :text
+      html = content_tag(:option, :value => "contains") do
+        "Contains"
+      end
+      html << content_tag(:option, :value => "does_not_contain") do
+        "Does not Contain"
+      end
+      html << content_tag(:option, :value => "is") do
+        "Is"
+      end
+      html << content_tag(:option, :value => "starts_with") do
+        "Starts with"
+      end
+      html << content_tag(:option, :value => "ends_with") do
+        "Ends with"
+      end
+    end
+    html
+  end
+end

data/lib/smart_filters.rb

@@ -0,0 +1,7 @@
+require 'smart_filters/smart_filter.rb'
+require 'smart_filters/view_helpers'
+require 'smart_filters/before_filter'
+
+ActionController::Base.send :before_filter, :sort_smart_filter
+ActionView::Base.send :include, ViewHelpers
+ActiveRecord::Base.send :extend, SmartFilter

data/lib/tasks/smart_filters.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :smart_filters do
+#   # Task goes here
+# end

data/rails/init.rb

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

data/spec/factories.rb

@@ -0,0 +1,9 @@
+Factory.define :address_book do |a|
+  a.name Faker::Name.name
+  a.address "#{Faker::Address.street_address}\n#{Faker::Address.city} #{Faker::Address.us_state} #{Faker::Address.zip_code}\nUSA"
+  a.company Faker::Company.name
+  a.email Faker::Internet.email
+  a.zipcode Faker::Address.zip_code
+  a.phone Faker::PhoneNumber.phone_number
+  a.domain Faker::Internet.domain_name
+end

data/spec/lib/smart_filters_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe SmartFilter do
+  before(:all) do
+    load_schema
+    class AddressBook < ActiveRecord::Base; end
+  end
+
+  describe ".smart_filter" do
+    let(:bob) { Factory(:address_book, :name => "Bob Martin", :zipcode => 12345) }
+    let(:david) { Factory(:address_book, :name => "David Henderson", :zipcode => 12347) }
+    let(:zheimer) { Factory(:address_book, :name => "Clarke Zheimer", :zipcode => 12348) }
+
+
+    before(:each) do
+      bob.save!
+      david.save!
+      zheimer.save!
+    end
+
+    it "returns an empty array if the criteria is unknown" do
+      AddressBook.smart_filter({:name => {"magic" => "abracadabra"}}).should == []
+    end
+    
+    it "returns all records if the column doesn't exist" do
+      AddressBook.smart_filter({:magician => {"magic" => "abracadabra"}}).should == AddressBook.find(:all)
+    end
+
+    context "when the argument contains more than one filter" do
+      it "returns the record matching all the criteria" do
+        AddressBook.smart_filter({:name => {"contains" => "Bob"},
+                                  :address => {"contains" => "Abracarab"}}).should be_empty
+        puts AddressBook.smart_filter({:name => {"contains" => "Bob"},
+                                  :name => {"contains" => "Martin"}}).inspect
+        AddressBook.smart_filter({:name => {"contains" => "Bob"},
+                                  :name => {"contains" => "Martin"}}).should have(1).item
+      end
+    end
+
+    context "when the column to apply smart filtering is string or text" do
+      context "when the criteria is 'contains'" do
+
+        it "returns the record with the column that contains the given string" do
+          AddressBook.smart_filter({:name => {"contains" => "Bob"}}).first.name.should == bob.name
+          AddressBook.smart_filter({:name => {"contains" => "Bob"}}).first.name.should include(bob.name.split.first)
+        end
+
+      end
+
+      context "when the criteria is 'is'" do
+
+        it "returns the record with the column of the exact given string" do
+          AddressBook.smart_filter({:name => {"is" => "Bob Martin"}}).first.name.should == bob.name
+        end
+
+      end
+
+      context "when the criteria is 'does_not_contain'" do
+
+        it "returns the record with the column that does not contain the given string" do
+          AddressBook.smart_filter({:name => {"does_not_contain" => "Bob Martin"}}).first.name.should_not == bob.name
+        end
+
+      end
+
+      context "when the criteria is starts_with" do
+
+        it "returns the record with the column that starts with the given string" do
+          AddressBook.smart_filter({:name => {"starts_with" => "David"}}).first.name.should =~ /^David[.]*/
+        end
+
+      end
+
+      context "when the criteria is ends_with" do
+
+        it "returns the record with the column that ends with the given string" do
+          AddressBook.smart_filter({:name => {"ends_with" => "Henderson"}}).first.name.should =~ /[.]*Henderson$/
+        end
+
+      end
+
+    end
+
+    context "when the column to apply smart filtering is integer" do
+
+      context "when the criteria is equals_to" do
+
+        it "returns records with the column that equals the given integer" do
+          AddressBook.smart_filter({:zipcode => {"equals_to" => "12345"}}).first.zipcode.should == 12345
+        end
+
+      end
+
+      context "when the criteria is greater_than" do
+        it "returns records with the column that is greater than the given integer" do
+          AddressBook.smart_filter({:zipcode => {"greater_than" => "12345"}}).first.zipcode.should > 12345
+        end
+      end
+
+      context "when the criteria is less_than" do
+        it "returns records with the column that is less than the given integer" do
+          AddressBook.smart_filter({:zipcode => {"less_than" => "12346"}}).first.zipcode.should < 12346
+        end
+      end
+
+      context "when the criteria is between" do
+        it "returns records with the column that is between the the given integers" do
+          AddressBook.smart_filter({:zipcode => {"between" => ["12343", "12348"]}}).should have(3).items
+          AddressBook.smart_filter({:zipcode => {"between" => ["12343", "12348"]}}).each do |contact|
+            contact.should satisfy { |c| c.zipcode >= 12343 && c.zipcode <= 12348 }
+          end
+        end
+      end
+
+    end
+
+    context "when the column to apply smart filtering is boolean" do
+      
+    end
+
+    context "when the column to apply smart filtering is date or date/time" do
+      
+    end
+
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--format nested
+--loadby mtime

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+ENV['RAILS_ENV'] = 'test'
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+
+require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+Spec::Runner.configure do |config|
+  # Configuration
+end

data/spec/support/database.yml

@@ -0,0 +1,17 @@
+sqlite3:
+  :adapter: sqlite3
+  :database: vendor/plugins/smart_filters/spec/smart_filters_plugin.sqlite3.db
+
+# postgresql:
+#   :adapter: postgresql
+#   :username: postgres
+#   :password: postgres
+#   :database: yaffle_plugin_test
+#   :min_messages: ERROR
+
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: root
+  :password: 
+  :database: smart_filters_plugin_test

data/spec/support/db.rb

@@ -0,0 +1,46 @@
+def load_schema
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+
+  db_adapter = ENV['DB']
+
+  # no db passed, try one of these fine config-free DBs before bombing.
+  db_adapter ||=
+    begin
+      require 'rubygems'
+      require 'sqlite'
+      'sqlite'
+    rescue MissingSourceFile
+      begin
+        require 'sqlite3'
+        'sqlite3'
+      rescue MissingSourceFile
+      end
+    end
+
+  if db_adapter.nil?
+    raise "No DB Adapter selected. Pass the DB= option to pick one, or install Sqlite or Sqlite3."
+  end
+
+  ActiveRecord::Base.establish_connection(config[db_adapter])
+  load(File.dirname(__FILE__) + "/schema.rb")
+  require File.dirname(__FILE__) + '/../../rails/init.rb'
+end
+
+def drop_database
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  begin
+    case config['adapter']
+    when 'mysql'
+      ActiveRecord::Base.establish_connection(config)
+      ActiveRecord::Base.connection.drop_database config['database']
+    when /^sqlite/
+      FileUtils.rm(File.join(RAILS_ROOT, config['database']))
+    when 'postgresql'
+      ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+      ActiveRecord::Base.connection.drop_database config['database']
+    end
+  rescue Exception => e
+    puts "Couldn't drop #{config['database']} : #{e.inspect}"
+  end
+end