filterable-models 0.0.2

data/.gitignore

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

data/Gemfile

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

data/Rakefile

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

data/filterable-models.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "filterable-models/version"
+
+Gem::Specification.new do |s|
+  s.name        = "filterable-models"
+  s.version     = Filterable::Models::VERSION
+  s.authors     = ["Marcelo Ribeiro"]
+  s.email       = ["ribeirodesenv@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Filter functionality for Rails models}
+  s.description = %q{Start filtering your models and adding a filter form to your scaffolds pretty fast}
+
+  s.rubyforge_project = "filterable-models"
+
+  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"]
+end

data/lib/filterable-models/base.rb

@@ -0,0 +1,230 @@
+module Filterable::Models
+  module Base
+    
+    def self.included(recipient)
+      recipient.extend(ModelClassMethods)
+      recipient.class_eval do
+        include ModelInstanceMethods
+      end
+    end
+
+    module ModelClassMethods
+
+      def filters(filters)
+        @filters = {}
+        @filterable = {}
+        @sorted_filterable = []
+        @filters = filters
+
+        if filters.is_a?(Array)
+          # Ruby 1.8 hash sorting is unpredictable, so we can use an array 
+          # to take care of the order and make it behave as expected
+          filters.each do |hash|
+            prepare_filters(hash)
+          end          
+        else
+          # Filters is a hash, so lets just move on
+          prepare_filters(filters)
+        end
+      end
+      
+      def prepare_filters(hash)
+        hash.map do |key, value| 
+          if value.is_a?(Hash)
+            value.map do |v_key, v_value|
+              @filterable["#{key.to_s.pluralize}.#{v_key}".to_sym] = v_value
+              @sorted_filterable << {"#{key.to_s.pluralize}.#{v_key}".to_sym => v_value}
+            end
+          else
+            @filterable[key] = value
+              @sorted_filterable << {key => value}            
+          end
+        end
+      end
+
+      def filter_options_for(attribute_name, options = [])
+        @filter_options ||= {}
+        @filter_options[attribute_name] = options
+      end
+
+      def filter_fields_per_column(fields_per_column = 5)
+        @fields_per_column = fields_per_column
+      end
+
+      def filter(filters = {})
+        filters ||= {}
+        filters = filters[self.to_s.underscore] ||= {}
+        @filter_conditions = []
+        @filter_conditions_values = []
+        @current_joins = []
+
+        keys = []
+
+        filters.map do |key, value|
+
+          unless value.blank?
+
+            if value.is_a?(Hash)
+              value.keys.collect{|k| k.to_s}.sort.each do |v_key|
+                v_key = v_key.to_sym
+                v_value = value[v_key]
+
+                keys << "#{key.to_s.pluralize}.#{v_key}".to_sym
+              end
+              @current_joins = build_joins(@current_joins, filters)
+            else
+              keys << key.to_sym
+            end
+
+            keys.each do |key|
+
+              if key.to_s =~ /_from/
+                key = key.to_s.gsub("_from", "").to_sym
+              elsif key.to_s =~ /_to/
+                key = key.to_s.gsub("_to", "").to_sym
+              end
+
+              if @filterable.has_key?(key)
+                filter_type = @filterable[key]
+
+                # related object attribute
+                if key.to_s =~ /\./
+                  v_keys = key.to_s.split(".")
+                  if filter_type =~ /_range/
+                    value_from  = filters[v_keys[0].singularize.to_sym]["#{v_keys[1]}_from".to_sym]
+                    value_to    = filters[v_keys[0].singularize.to_sym]["#{v_keys[1]}_to".to_sym]
+                  else
+                    value = filters[v_keys[0].singularize.to_sym][v_keys[1].to_sym]
+                  end
+                else
+                  if filter_type =~ /_range/
+                    value_from  = filters["#{key}_from".to_sym]
+                    value_to    = filters["#{key}_to".to_sym]
+                  else
+                    value = filters[key]
+                  end
+                end
+
+                unless value.blank?
+                  if value == 'false'
+                    value = false
+                  end
+
+                  if value == 'true'
+                    value = true
+                  end
+
+  								compare_key = key.to_s
+  								unless key.to_s =~ /\./
+  									compare_key = "#{self.name.to_s.tableize}.#{key.to_s}"
+  								end
+                  case filter_type
+                  when "string"
+                    @filter_conditions << "#{compare_key} LIKE ?"
+                    @filter_conditions_values << "%#{value}%"
+                  when "exact_string"
+                    @filter_conditions << "#{compare_key} = ?"
+                    @filter_conditions_values << value
+                  when "date_range", "float_range"
+                    if value_from != "" && value_to != ""
+                      @filter_conditions << "(#{compare_key} >= ? and #{compare_key} <= ?)"
+                      @filter_conditions_values << value_from
+                      @filter_conditions_values << value_to
+                    elsif value_from != ""
+                      @filter_conditions << "#{compare_key} >= ?"
+                      @filter_conditions_values << value_from
+                    elsif value_to != ""
+                      @filter_conditions << "#{compare_key} <= ?"
+                      @filter_conditions_values << value_to                      
+                    end
+                  when "drop_down"
+                    @filter_conditions << "#{compare_key} = ?"
+                    @filter_conditions_values << value
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        filter_scope = where([@filter_conditions.join(" AND ")] + @filter_conditions_values).group("#{self.name.tableize}.id")
+        if @current_joins.any?
+          filter_scope = filter_scope.joins(@current_joins)
+        end
+        
+        filter_scope
+      end
+
+      def build_joins(current_joins = {}, filters = {})
+        @self_object_name = self.name.underscore
+        @self_table_name = @self_object_name.pluralize
+        @self_filter_joins = []
+
+        filters.map do |key, value|
+
+          if value.is_a?(Hash)
+            unless filters_are_empty(value)
+
+              @self_object = self.new
+
+              if @self_object.attributes.include?("#{key}_id")
+                # belogns to
+  							@self_filter_joins += [key.to_sym]
+              else
+                @related_object = key.to_s.camelize.constantize.new
+
+                if @related_object.attributes.include?("#{@self_object_name}_id")
+                  # has many - need to figure out how to solve it for has one.
+                  @self_filter_joins += ["#{key.to_s.pluralize}".to_sym]
+                elsif @self_object.methods.include?("#{key}_ids")
+                  # has and_belongs_to_many
+                  @self_filter_joins += ["#{key.to_s.pluralize}".to_sym]
+                end
+
+              end
+            end
+          end
+
+        end
+
+        if @self_filter_joins.size > 0
+          current_joins ||= []
+          current_joins += @self_filter_joins
+        end
+
+        current_joins
+      end
+
+      def filters_are_empty(filters)
+        filters.map do |key, value|
+          return false unless value.blank?
+        end
+        true
+      end
+
+      def filterable
+        @filterable
+      end
+
+      def filter_options
+        @filter_options
+      end
+
+      def fields_per_column
+        @fields_per_column ||= 5
+      end
+
+      def filters_hash
+        @filters
+      end
+
+      def sorted_filterable
+        @sorted_filterable
+      end
+
+    end
+
+    module ModelInstanceMethods
+    end
+  end    
+end

data/lib/filterable-models/helper.rb

@@ -0,0 +1,145 @@
+module Filterable::Models
+  module Helper
+    def filter_form_for(object, params = {}, options = {})
+      @params       = params
+      form_html     = %{<form action="" method="get">} + "\n"
+      elements_html = ""
+
+      klass = object.to_s.camelize.constantize
+
+      return if klass.filterable.blank?
+
+      filter_fields_count = 1
+
+      klass.sorted_filterable.each do |filterable|
+
+        filterable.map do |key, value|
+          key = key.to_sym
+          value = klass.filterable[key]
+
+          case value
+          when 'string'
+            elements_html += text_filter_tag(object, key) + "\n"
+          when 'exact_string'
+            elements_html += text_filter_tag(object, key) + "\n"
+          when 'date_range', 'float_range'
+            elements_html += text_filter_tag(object, key, "from") + "\n"
+            elements_html += text_filter_tag(object, key, "to") + "\n"
+            filter_fields_count += 1
+          when 'drop_down'
+            elements_html += select_filter_tag(object, key) + "\n"
+          end
+        end
+
+        if filter_fields_count >= (klass.fields_per_column)
+          elements_html += "</ul><ul>" + "\n"
+          filter_fields_count  = 1
+        else
+          filter_fields_count += 1
+        end
+
+      end
+
+      form_html += content_tag(:ul, elements_html.html_safe) + "\n"
+      form_html += %{<div style="clear:both;"><!-- --></div>}.html_safe
+      form_html += submit_tag(t("Filter").html_safe)
+      form_html += "</form>"
+
+      content_tag(:div, form_html.html_safe, {:class => "filter-form"}.merge(options)).html_safe
+    end
+
+    def text_filter_tag(object, key, extra = nil)
+      filter_element_data     = get_filter_element_data(object, key, extra)
+      filter_field_label_text = filter_element_data[:label_text]
+      filter_field_id         = filter_element_data[:element_id]
+      filter_field_name       = filter_element_data[:element_name]
+      filter_field_value      = filter_element_data[:element_value]
+
+      content_tag(:li, 
+                  label_tag(filter_field_id, filter_field_label_text) + "<br/>".html_safe + 
+                  text_field_tag(filter_field_name, filter_field_value)).html_safe
+    end
+
+    def select_filter_tag(object, key, extra = nil)
+      filter_element_data     = get_filter_element_data(object, key, extra)
+      filter_field_label_text = filter_element_data[:label_text]
+      filter_field_id         = filter_element_data[:element_id]
+      filter_field_name       = filter_element_data[:element_name]
+      filter_field_value      = filter_element_data[:element_value]
+
+      content_tag(:li, 
+                  label_tag(filter_field_id, filter_field_label_text) + "<br/>".html_safe + 
+                  select_tag(filter_field_name, select_values_for(object, key, filter_field_value))).html_safe
+    end
+
+    def select_values_for(object, key, value)
+      klass = object.to_s.camelize.constantize
+      filter_options = klass.filter_options[key]
+
+      options_html = content_tag(:option, t("Please Select"), :value => "")
+
+      if filter_options.is_a?(Hash)
+        filter_options.keys.collect{|k| k.to_s}.sort.each do |option_key|
+          selected = {}
+          if value == filter_options[option_key]
+            selected = {:selected => "selected"}
+          end
+          options_html += content_tag(:option, t(option_key.to_s.titleize), {:value => filter_options[option_key]}.merge(selected))
+        end
+      elsif filter_options.is_a?(Array)
+        filter_options.each do |option|
+          selected = {}
+          if value == option
+            selected = {:selected => "selected"}
+          end
+          options_html += content_tag(:option, t(option.titleize), {:value => option}.merge(selected))
+        end
+      end
+
+      options_html.html_safe
+    end
+
+    def get_filter_element_data(object, key, extra)
+      params_prefix                   = :filters
+      @params                         ||= {}
+      @params[params_prefix]          ||= {}
+      @params[params_prefix][object]  ||= {}
+
+      if key.to_s =~ /\./
+        key_parts = key.to_s.split(".")
+        key_object = key_parts.first.singularize.to_sym
+        key_object_att = key_parts.last.to_sym
+
+        @params[params_prefix][object][key_object] ||= {}
+        key = "#{key_object}_#{key_object_att}"
+
+        if extra.nil?
+          element_name = "#{params_prefix}[#{object}][#{key_object}][#{key_object_att}]"
+          element_value = @params[params_prefix][object][key_object][key_object_att]
+          element_id = "#{params_prefix}_#{object}_#{key}"
+        else
+          element_name = "#{params_prefix}[#{object}][#{key_object}][#{key_object_att}_#{extra}]"
+          element_value = @params[params_prefix][object][key_object]["#{key_object_att}_#{extra}"]
+          element_id = "#{params_prefix}_#{object}_#{key}_#{extra}"
+        end
+      else
+        if extra.nil?
+          element_name = "#{params_prefix}[#{object}][#{key}]"
+          element_value = @params[params_prefix][object][key]
+          element_id = "#{params_prefix}_#{object}_#{key}"
+        else
+          element_name = "#{params_prefix}[#{object}][#{key}_#{extra}]"
+          element_value = @params[params_prefix][object]["#{key}_#{extra}".to_sym]
+          element_id = "#{params_prefix}_#{object}_#{key}_#{extra}"
+        end
+      end
+
+      element_data = {}
+      element_data[:label_text]     = t("#{key.to_s.humanize}#{extra ? "_#{extra}" : ""}".to_s.titleize) + ": "
+      element_data[:element_id]     = element_id
+      element_data[:element_name]   = element_name
+      element_data[:element_value]  = element_value
+      element_data
+    end
+  end
+end

data/lib/filterable-models/version.rb

@@ -0,0 +1,5 @@
+module Filterable
+  module Models
+    VERSION = "0.0.2"
+  end
+end

data/lib/filterable-models.rb

@@ -0,0 +1,7 @@
+require "filterable-models/version"
+require "filterable-models/base"
+require "filterable-models/helper"
+
+ActiveRecord::Base.send :include, Filterable::Models::Base
+ActionView::Helpers::FormTagHelper.send :include, Filterable::Models::Helper
+ActionView::Base.send :include, Filterable::Models::Helper

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: filterable-models
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Marcelo Ribeiro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-04 00:00:00 Z
+dependencies: []
+
+description: Start filtering your models and adding a filter form to your scaffolds pretty fast
+email: 
+- ribeirodesenv@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- filterable-models.gemspec
+- lib/filterable-models.rb
+- lib/filterable-models/base.rb
+- lib/filterable-models/helper.rb
+- lib/filterable-models/version.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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: filterable-models
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Filter functionality for Rails models
+test_files: []
+