searchgasm 0.9.2 → 0.9.3

data/CHANGELOG

@@ -1,3 +1,5 @@
+v0.9.3. Changed structure of conditions to have their own class. Making it easier to add your own conditions.
+
 v0.9.2. Enhanced protection
 
 v0.9.1. Added aliases for datetime, date, time, and timestamp attrs. You could call created_at_after, mow you can also call created_after.

data/Manifest

@@ -2,9 +2,23 @@ CHANGELOG
 init.rb
 lib/searchgasm/active_record/associations.rb
 lib/searchgasm/active_record/base.rb
-lib/searchgasm/helpers.rb
 lib/searchgasm/search/base.rb
-lib/searchgasm/search/condition.rb
+lib/searchgasm/search/condition_types/begins_with_condition.rb
+lib/searchgasm/search/condition_types/child_of_condition.rb
+lib/searchgasm/search/condition_types/condition.rb
+lib/searchgasm/search/condition_types/contains_condition.rb
+lib/searchgasm/search/condition_types/descendant_of_condition.rb
+lib/searchgasm/search/condition_types/does_not_equal_condition.rb
+lib/searchgasm/search/condition_types/ends_with_condition.rb
+lib/searchgasm/search/condition_types/equals_condition.rb
+lib/searchgasm/search/condition_types/greater_than_condition.rb
+lib/searchgasm/search/condition_types/greater_than_or_equal_to_condition.rb
+lib/searchgasm/search/condition_types/inclusive_descendant_of_condition.rb
+lib/searchgasm/search/condition_types/keywords_condition.rb
+lib/searchgasm/search/condition_types/less_than_condition.rb
+lib/searchgasm/search/condition_types/less_than_or_equal_to_condition.rb
+lib/searchgasm/search/condition_types/sibling_of_condition.rb
+lib/searchgasm/search/condition_types/tree_condition.rb
 lib/searchgasm/search/conditions.rb
 lib/searchgasm/search/utilities.rb
 lib/searchgasm/version.rb
@@ -20,8 +34,7 @@ test/libs/acts_as_tree.rb
 test/libs/rexml_fix.rb
 test/test_active_record_associations.rb
 test/test_active_record_base.rb
-test/test_active_record_protection.rb
 test/test_helper.rb
 test/test_searchgasm_base.rb
-test/test_searchgasm_condition.rb
+test/test_searchgasm_condition_types.rb
 test/test_searchgasm_conditions.rb

data/README.mdown

@@ -2,11 +2,11 @@
 
 Searchgasm is orgasmic. Maybe not orgasmic, but you will get aroused. So go grab a towel and let's dive in.
 
-Searchgasm was a super secret tool of mine until I decided to share with the world. It has saved me tons of time, allowed me to write less code, made searching painless, and kept my controllers DRY.
+Searchgasm was a super secret tool of mine until I decided to share with the world. It has saved me tons of time, allowed me to write less code, made searching painless, and kept my controllers DRY and simple.
 
 It originated to satisfy a VERY simple need: so that I could use my form builder when making search forms. Sounds simple right? The goal was to use an object, that represents a search, just like an ActiveRecord object in form\_for and fields\_for.
 
-I'm a big fan of understanding what I'm using, so here's a quick explanation: The design behind this plugin is pretty simple. The search object "santiizes" down into the options passed into ActiveRecord::Base.find(). It basically serves as a transparent filter between you and ActiveRecord::Base.find(). This filter provides "enhancements" that get translated into options that ActiveRecord::Base.find() can understand. This doesn't step on the toes or dig into he internals of ActiveRecord. It uses what ActiveRecord provides publicly. Letting ActiveRecord do all of the hard work and keeping this plugin solid and less brittle.
+I'm a big fan of understanding what I'm using, so here's a quick explanation: The design behind this plugin is pretty simple. The search object "santiizes" down into the options passed into ActiveRecord::Base.find(). It basically serves as a transparent filter between you and ActiveRecord::Base.find(). This filter provides "enhancements" that get translated into options that ActiveRecord::Base.find() can understand. It doesn't dig into the ActiveRecord internals, it only uses what is publicly available. It jumps in and helps out only when needed, otherwise it sits back and lets ActiveRecord do all of the work. Between that and the extensive tests this is a solid plugin.
 
 Here's where you get aroused...
 
@@ -18,7 +18,7 @@ Here's where you get aroused...
         @users, @users_count = @search.all, @search.count
     end
 
-Now your view:
+Now your view, isn't it nice to use form builder again?
 
     # app/views/users/index.html.erb
     <%= form_for :conditions, @search.conditions, :url => users_path do |f| %>
@@ -63,7 +63,9 @@ Now go into your console and try out any of these example with your own models.
         :page => 3          # offset 60
     )
 
-## Detailed Example w/ object based searching
+Instead of using the "all" method you could use any search method: first, find(:all), find(:first), count, sum, average, etc
+
+## Detailed Example w/ object based searching (great for form\_for for fields\_for)
 
     # Instantiate
     @search = User.new_search(
@@ -137,7 +139,7 @@ If you want to be hardcore:
     search.per_page = 20
     search.all
 
-## Search with conditions only (great for form\_for or fields\_for)
+## Search with conditions only
 
     conditions = User.new_conditions(:age_gt => 18)
     conditions.first_name_contains = "Ben"
@@ -177,16 +179,15 @@ For tree data structures you get a few nifty methods. Let's assume Users is a tr
     User.all(:conditions => {:sibling_of => User.roots.first})
     User.all(:conditions => {:sibling_of => User.roots.first.id})
     
-    # Descendent of (includes all recursive children: children, grand children, great grand children, etc)
-    User.all(:conditions => {:descendent_of => User.roots.first})
-    User.all(:conditions => {:descendent_of => User.roots.first.id})
+    # Descendant of (includes all recursive children: children, grand children, great grand children, etc)
+    User.all(:conditions => {:descendant_of => User.roots.first})
+    User.all(:conditions => {:descendant_of => User.roots.first.id})
     
-    # Inclusive descendent_of. Same as above but includes the root
-    User.all(:conditions => {:inclusive_descendent_of => User.roots.first})
-    User.all(:conditions => {:inclusive_descendent_of => User.roots.first.id})
+    # Inclusive descendant_of. Same as above but includes the root
+    User.all(:conditions => {:inclusive_descendant_of => User.roots.first})
+    User.all(:conditions => {:inclusive_descendant_of => User.roots.first.id})
     
 
-
 ## Available anywhere (relationships & named scopes)
 
 Not only can you use searchgasm when searching, but you can use it when setting up relationships or named scopes:
@@ -198,7 +199,7 @@ Not only can you use searchgasm when searching, but you can use it when setting
 
 ## Always use protection...against SQL injections
 
-If there is one thing we all know, it's to always use protection. That's why searchgasm protects you by default. The new\_search and new\_conditions methods are protected by default. This means that various checks are done to ensure it is not possible to perform any type of SQL injection. But this also limits how you can search, meaning you can't write raw SQL. If you want to be daring and search without protection prepare to accept the consequences. All that you have to do is add ! to the end of the methods: new\_search! and new\_conditions!. That was an awkward paragraph. Let's move on.
+If there is one thing we all know, it's to always use protection. That's why searchgasm protects you by default. The new\_search and new\_conditions methods are protected by default. This means that various checks are done to ensure it is not possible to perform any type of SQL injection. But this also limits how you can search, meaning you can't write raw SQL. If you want to be daring and search without protection prepare to accept the consequences. All that you have to do is add ! to the end of the methods: new\_search! and new\_conditions!.
 
 ### Protected from SQL injections
 
@@ -229,16 +230,18 @@ Depending on the type, each column comes preloaded with a bunch of nifty conditi
     => :greater_than, :greater_than_or_equal_to, :less_than, :less_than_or_equal_to
 
     tree data structures (see above "searching trees")
-    => :child_of, :sibling_of, :descendent_of, :inclusive_descendent_of
+    => :child_of, :sibling_of, :descendant_of, :inclusive_descendant_of
 
 Some of these conditions come with aliases, so you have your choice how to call the conditions. For example you can use "greater\_than" or "gt":
 
     :equals;                    => :is
     :does_not_equal             => :is_not, :not
-    :begins_with                => :starts_with
-    :contains                   => :like
+    :begins_with                => :starts_with, :bw, :start
+    :contains                   => :like, :has
+    :ends_with                  => :ew, :ends, :end
     :greater_than               => :gt, :after
     :greater_than_or_equal_to   => :at_least, :gte
+    :keywords                   => :kwords, :kw
     :less_than                  => :lt, :before
     :less_than_or_equal_to      => :at_most, :lte
 

data/lib/searchgasm/search/base.rb

@@ -20,12 +20,10 @@ module BinaryLogic
         end
         
         (::ActiveRecord::Base.valid_find_options - [:conditions]).each do |option|
-          src = <<-SRC
+          class_eval <<-end_eval
             def #{option}(sanitize = false); options[:#{option}]; end
             def #{option}=(value); self.options[:#{option}] = value; end
-          SRC
-          
-          class_eval src
+          end_eval
         end
         
         alias_method :per_page, :limit

data/lib/searchgasm/search/condition_types/begins_with_condition.rb

@@ -0,0 +1,28 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class BeginsWithCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless string_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              ["#{column.name}_bw", "#{column.name}_starts_with", "#{column.name}_start"]
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "#{value}%"]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::BeginsWithCondition)
+    end
+  end
+end
+
+BinaryLogic::Searchgasm::Search::Conditions.register_condition(BinaryLogic::Searchgasm::Search::ConditionTypes::BeginsWithCondition)

data/lib/searchgasm/search/condition_types/child_of_condition.rb

@@ -0,0 +1,17 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class ChildOfCondition < TreeCondition
+          def to_conditions(value)
+            parent_association = klass.reflect_on_association(:parent)
+            foreign_key_name = (parent_association && parent_association.options[:foreign_key]) || "parent_id"
+            ["#{quoted_table_name}.#{quote_column_name(foreign_key_name)} = ?", (value.is_a?(klass) ? value.send(klass.primary_key) : value)]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::ChildOfCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/condition.rb

@@ -0,0 +1,107 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class Condition
+          include Utilities
+        
+          attr_accessor :column, :klass
+          attr_reader :value
+        
+          class << self
+            def condition_name
+              name.split("::").last.scan(/(.*)Condition/)[0][0].underscore
+            end
+            
+            def name_for_column(column)
+              "#{column.name}_#{condition_name}"
+            end
+            
+            def aliases_for_column(column)
+              []
+            end
+            
+            def name_for_klass(klass)
+              nil
+            end
+            
+            def aliases_for_klass(klass)
+              []
+            end
+            
+            def string_column?(column)
+              [:string, :text].include?(column.type)
+            end
+
+            def comparable_column?(column)
+              [:integer, :float, :decimal, :datetime, :timestamp, :time, :date].include?(column.type)
+            end
+          end
+        
+          def initialize(klass, column = nil)          
+            self.klass = klass
+            self.column = column.is_a?(String) ? klass.columns_hash[column] : column
+          end
+        
+          def explicitly_set_value=(value)
+            @explicitly_set_value = value
+          end
+        
+          # Need this if someone wants to actually use nil in a meaningful way
+          def explicitly_set_value?
+            @explicitly_set_value == true
+          end
+        
+          def ignore_blanks?
+            true
+          end
+          
+          def name
+            column ? self.class.name_for_column(column) : self.class.name_for_klass(klass)
+          end
+          
+          def condition_name
+            self.class.condition_name
+          end
+        
+          def quote_column_name(column_name)
+            klass.connection.quote_column_name(column_name)
+          end
+          
+          def quoted_column_name
+            quote_column_name(column.name)
+          end
+          
+          def quote_table_name(table_name)
+            klass.connection.quote_table_name(table_name)
+          end
+          
+          def quoted_table_name
+            quote_table_name(klass.table_name)
+          end
+          
+          def sanitize(alt_value = nil)
+            return unless explicitly_set_value?
+            v = alt_value || value
+            if v.is_a?(Array) && !["equals", "does_not_equal"].include?(condition_name)
+              merge_conditions(*v.collect { |i| sanitize(i) })
+            else
+              v = v.utc if column && [:time, :timestamp, :datetime].include?(column.type) && klass.time_zone_aware_attributes && !klass.skip_time_zone_conversion_for_attributes.include?(column.name.to_sym)
+              to_conditions(v)
+            end
+          end
+        
+          def value
+            @value.is_a?(String) ? column.type_cast(@value) : @value
+          end
+        
+          def value=(v)
+            return if ignore_blanks? && v.blank?
+            self.explicitly_set_value = true
+            @value = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/contains_condition.rb

@@ -0,0 +1,26 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class ContainsCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless string_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              ["#{column.name}_like", "#{column.name}_has"]
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "%#{value}%"]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::ContainsCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/descendant_of_condition.rb

@@ -0,0 +1,30 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class DescendantOfCondition < TreeCondition
+          def to_conditions(value)
+            # Wish I knew how to do this in SQL
+            root = (value.is_a?(klass) ? value : klass.find(value)) rescue return
+            strs = []
+            subs = []
+            all_children_ids(root).each do |child_id|
+              strs << "#{quoted_table_name}.#{quote_column_name(klass.primary_key)} = ?"
+              subs << child_id
+            end
+            [strs.join(" OR "), *subs]
+          end
+          
+          private
+            def all_children_ids(record)
+              ids = record.children.collect { |child| child.send(klass.primary_key) }
+              record.children.each { |child| ids += all_children_ids(child) }
+              ids
+            end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::DescendantOfCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/does_not_equal_condition.rb

@@ -0,0 +1,34 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class DoesNotEqualCondition < Condition
+          class << self
+            def aliases_for_column(column)
+              ["#{column.name}_is_not", "#{column.name}_not"]
+            end
+          end
+          
+          def ignore_blanks?
+            false
+          end
+          
+          def to_conditions(value)
+            # Delegate to equals and then change
+            condition = EqualsCondition.new(klass, column)
+            condition.value = value
+            
+            sql = condition.sanitize
+            sql.gsub!(/ IS /, " IS NOT ")
+            sql.gsub!(/ BETWEEN /, " NOT BETWEEN ")
+            sql.gsub!(/ IN /, " NOT IN ")
+            sql.gsub!(/=/, "!=")
+            sql
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::DoesNotEqualCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/ends_with_condition.rb

@@ -0,0 +1,26 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class EndsWithCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless string_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              ["#{column.name}_ew", "#{column.name}_ends", "#{column.name}_end"]
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "%#{value}"]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::EndsWithCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/equals_condition.rb

@@ -0,0 +1,26 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class EqualsCondition < Condition
+          class << self
+            def aliases_for_column(column)
+              ["#{column.name}", "#{column.name}_is"]
+            end
+          end
+          
+          def ignore_blanks?
+            false
+          end
+          
+          def to_conditions(value)
+            # Let ActiveRecord handle this
+            klass.send(:sanitize_sql_hash_for_conditions, {column.name => value})
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::EqualsCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/greater_than_condition.rb

@@ -0,0 +1,31 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class GreaterThanCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless comparable_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              column_names = [column.name]
+              column_names << column.name.gsub(/_at$/, "") if [:datetime, :timestamp, :time, :date].include?(column.type) && column.name =~ /_at$/
+              
+              aliases = []
+              column_names.each { |column_name| aliases += ["#{column_name}_gt", "#{column_name}_after"] }
+              aliases
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} > ?", value]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::GreaterThanCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/greater_than_or_equal_to_condition.rb

@@ -0,0 +1,26 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class GreaterThanOrEqualToCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless comparable_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              ["#{column.name}_gte", "#{column.name}_at_least"]
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} >= ?", value]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::GreaterThanOrEqualToCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/inclusive_descendant_of_condition.rb

@@ -0,0 +1,19 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class InclusiveDescendantOfCondition < TreeCondition
+          include Search::Utilities
+          
+          def to_conditions(value)
+            condition = DescendantOfCondition.new(klass, column)
+            condition.value = value
+            merge_conditions(["#{quoted_table_name}.#{quote_column_name(klass.primary_key)} = ?", (value.is_a?(klass) ? value.send(klass.primary_key) : value)], condition.sanitize, :any => true)
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::InclusiveDescendantOfCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/keywords_condition.rb

@@ -0,0 +1,39 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class KeywordsCondition < Condition
+          BLACKLISTED_WORDS = ('a'..'z').to_a + ["about", "an", "are", "as", "at", "be", "by", "com", "de", "en", "for", "from", "how", "in", "is", "it", "la", "of", "on", "or", "that", "the", "the", "this", "to", "und", "was", "what", "when", "where", "who", "will", "with", "www"] # from ranks.nl        
+          
+          class << self
+            def name_for_column(column)
+              return unless string_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              ["#{column.name}_kwords", "#{column.name}_kw"]
+            end
+          end
+          
+          def to_conditions(value)
+            strs = []
+            subs = []
+            
+            search_parts = value.gsub(/,/, " ").split(/ /).collect { |word| word.downcase.gsub(/[^[:alnum:]]/, ''); }.uniq.select { |word| !BLACKLISTED_WORDS.include?(word.downcase) && !word.blank? }
+            search_parts.each do |search_part|
+              strs << "#{quoted_table_name}.#{quoted_column_name} LIKE ?"
+              subs << "%#{search_part}%"
+            end
+            
+            return if strs.blank?
+            
+            [strs.join(" AND "), *subs]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::KeywordsCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/less_than_condition.rb

@@ -0,0 +1,31 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class LessThanCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless comparable_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              column_names = [column.name]
+              column_names << column.name.gsub(/_at$/, "") if [:datetime, :timestamp, :time, :date].include?(column.type) && column.name =~ /_at$/
+              
+              aliases = []
+              column_names.each { |column_name| aliases += ["#{column_name}_lt", "#{column_name}_before"] }
+              aliases
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} < ?", value]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::LessThanCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/less_than_or_equal_to_condition.rb

@@ -0,0 +1,26 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class LessThanOrEqualToCondition < Condition
+          class << self
+            def name_for_column(column)
+              return unless comparable_column?(column)
+              super
+            end
+            
+            def aliases_for_column(column)
+              ["#{column.name}_lte", "#{column.name}_at_most"]
+            end
+          end
+          
+          def to_conditions(value)
+            ["#{quoted_table_name}.#{quoted_column_name} <= ?", value]
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::LessThanOrEqualToCondition)
+    end
+  end
+end

data/lib/searchgasm/search/condition_types/sibling_of_condition.rb

@@ -0,0 +1,22 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module ConditionTypes
+        class SiblingOfCondition < TreeCondition
+          include Search::Utilities
+          
+          def to_conditions(value)
+            parent_association = klass.reflect_on_association(:parent)
+            foreign_key_name = (parent_association && parent_association.options[:foreign_key]) || "parent_id"
+            parent_id = (value.is_a?(klass) ? value : klass.find(value)).send(foreign_key_name)
+            condition = ChildOfCondition.new(klass, column)
+            condition.value = parent_id
+            merge_conditions(["#{quoted_table_name}.#{quote_column_name(klass.primary_key)} != ?", (value.is_a?(klass) ? value.send(klass.primary_key) : value)], condition.sanitize)
+          end
+        end
+      end
+      
+      Conditions.register_condition(ConditionTypes::SiblingOfCondition)
+    end
+  end
+end