searchgasm 0.9.6 → 0.9.7

data/lib/searchgasm/active_record/base.rb

@@ -1,76 +1,90 @@
-module BinaryLogic
-  module Searchgasm
-    module ActiveRecord
-      module Base
-        def calculate_with_searchgasm(*args)
-          options = args.extract_options!
-          options = sanitize_options_with_searchgasm(options)
-          args << options
-          calculate_without_searchgasm(*args)
-        end
-      
-        def find_with_searchgasm(*args)
-          options = args.extract_options!
-          options = sanitize_options_with_searchgasm(options)
-          args << options
-          find_without_searchgasm(*args)
-        end
-      
-        def scope_with_searchgasm(method, key = nil)
-          scope = scope_without_searchgasm(method, key)
-          return sanitize_options_with_searchgasm(scope) if key.nil? && method == :find && !scope.blank?
-          scope
-        end
+module Searchgasm
+  module ActiveRecord #:nodoc: all
+    module Base
+      def calculate_with_searchgasm(*args)
+        options = args.extract_options!
+        options = sanitize_options_with_searchgasm(options)
+        args << options
+        calculate_without_searchgasm(*args)
+      end
+    
+      def find_with_searchgasm(*args)
+        options = args.extract_options!
+        options = sanitize_options_with_searchgasm(options)
+        args << options
+        find_without_searchgasm(*args)
+      end
+    
+      def scope_with_searchgasm(method, key = nil)
+        scope = scope_without_searchgasm(method, key)
+        return sanitize_options_with_searchgasm(scope) if key.nil? && method == :find && !scope.blank?
+        scope
+      end
+    
+      def build_conditions(values = {}, &block)
+        conditions = searchgasm_conditions
+        conditions.protect = true
+        conditions.conditions = values
+        yield conditions if block_given?
+        conditions
+      end
+    
+      def build_conditions!(values = {}, &block)
+        conditions = searchgasm_conditions(values)
+        yield conditions if block_given?
+        conditions
+      end
+    
+      def build_search(options = {}, &block)
+        search = searchgasm_searcher
+        search.protect = true
+        search.options = options
+        yield search if block_given?
+        search
+      end
+    
+      def build_search!(options = {}, &block)
+        search = searchgasm_searcher(options)
+        yield search if block_given?
+        search
+      end
       
-        def build_conditions(values = {}, &block)
-          conditions = searchgasm_conditions
-          conditions.protect = true
-          conditions.value = values
-          yield conditions if block_given?
-          conditions
-        end
+      def conditions_protected(*conditions)
+        write_inheritable_attribute(:conditions_protected, Set.new(conditions.map(&:to_s)) + (protected_conditions || []))
+      end
+
+      def protected_conditions
+        read_inheritable_attribute(:conditions_protected)
+      end
       
-        def build_conditions!(values = {}, &block)
-          conditions = searchgasm_conditions(values)
-          yield conditions if block_given?
-          conditions
+      def conditions_accessible(*conditions)
+        write_inheritable_attribute(:conditions_accessible, Set.new(conditions.map(&:to_s)) + (protected_conditions || []))
+      end
+
+      def accessible_conditions
+        read_inheritable_attribute(:conditions_accessible)
+      end
+    
+      private
+        def sanitize_options_with_searchgasm(options = {})
+          return options unless Searchgasm::Search::Base.needed?(self, options)
+          searchgasm_searcher(options).sanitize
         end
       
-        def build_search(options = {}, &block)
-          search = searchgasm_searcher
-          search.protect = true
-          search.options = options
-          yield search if block_given?
-          search
+        def searchgasm_conditions(options = {})
+          Searchgasm::Conditions::Base.new(self, options)
         end
       
-        def build_search!(options = {}, &block)
-          search = searchgasm_searcher(options)
-          yield search if block_given?
-          search
+        def searchgasm_searcher(options = {})
+          Searchgasm::Search::Base.new(self, options)
         end
-      
-        private
-          def sanitize_options_with_searchgasm(options = {})
-            return options unless BinaryLogic::Searchgasm::Search::Base.needed?(self, options)
-            searchgasm_searcher(options).sanitize
-          end
-        
-          def searchgasm_conditions(options = {})
-            BinaryLogic::Searchgasm::Search::Conditions.new(self, options)
-          end
-        
-          def searchgasm_searcher(options = {})
-            BinaryLogic::Searchgasm::Search::Base.new(self, options)
-          end
-      end
     end
   end
 end
 
-ActiveRecord::Base.send(:extend, BinaryLogic::Searchgasm::ActiveRecord::Base)
+ActiveRecord::Base.send(:extend, Searchgasm::ActiveRecord::Base)
 
-module ::ActiveRecord
+module ActiveRecord #:nodoc: all
   class Base
     class << self
       alias_method_chain :calculate, :searchgasm

data/lib/searchgasm/condition/base.rb

@@ -0,0 +1,127 @@
+module Searchgasm
+  module Condition # :nodoc:
+    # = Conditions condition
+    #
+    # The base class for creating a condition. Your custom conditions should extend this class.
+    # See Searchgasm::Conditions::Base.register_condition on how to write your own condition.
+    class Base
+      include Utilities
+      
+      attr_accessor :column, :klass
+      attr_reader :value
+    
+      class << self
+        # Name of the condition inferred from the class name
+        def condition_name
+          name.split("::").last.gsub(/Condition$/, "").underscore
+        end
+        
+        # I pass you a column you tell me what to call the condition. If you don't want to use this condition for the column
+        # just return nil
+        def name_for_column(column)
+          "#{column.name}_#{condition_name}"
+        end
+        
+        # Alias methods for the column condition.
+        def aliases_for_column(column)
+          []
+        end
+        
+        # Sane as name_for_column but for the class as a whole. For example the tree methods apply to the class as a whole and not
+        # specific columns. Any condition that applies to columns should probably return nil here.
+        def name_for_klass(klass)
+          nil
+        end
+        
+        # Alias methods for the klass condition
+        def aliases_for_klass(klass)
+          []
+        end
+        
+        # A utility method for using in name_for_column. For example the keywords condition only applied to string columns, the great than condition doesnt.
+        def string_column?(column)
+          [:string, :text].include?(column.type)
+        end
+
+        # A utility method for using in name_for_column. For example you wouldn't want a string column to use the greater thann condition, but you would for an integer column.
+        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
+    
+      # Allows nils to be meaninful values
+      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
+      
+      # In most cases a blank value should be ignored, except for conditions like equals. A blank value is meaningful there, but a blank value for they keyswords condition is not.
+      def ignore_blanks?
+        true
+      end
+      
+      # A convenience method for the name of the method for that specific column or klass
+      def name
+        column ? self.class.name_for_column(column) : self.class.name_for_klass(klass)
+      end
+      
+      # A convenience method for the name of this condition
+      def condition_name
+        self.class.condition_name
+      end
+    
+      # Quotes a column name properly for sql.
+      def quote_column_name(column_name)
+        klass.connection.quote_column_name(column_name)
+      end
+      
+      # A convenience method for using when writing your sql in to_conditions. This is the proper way to use a column name in a query for most databases
+      def quoted_column_name
+        quote_column_name(column.name)
+      end
+      
+      # Quotes a table name properly for sql
+      def quote_table_name(table_name)
+        klass.connection.quote_table_name(table_name)
+      end
+      
+      # A convenience method for using when writing your sql in to_conditions. This is the proper way to use a table name in a query for most databases
+      def quoted_table_name
+        quote_table_name(klass.table_name)
+      end
+      
+      # You should refrain from overwriting this method, it performs various tasks before callign your to_conditions method, allowing you to keep to_conditions simple.
+      def sanitize(alt_value = nil) # :nodoc:
+        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
+    
+      # The value for the condition
+      def value
+        @value.is_a?(String) ? column.type_cast(@value) : @value
+      end
+    
+      # Sets the value for the condition, will ignore place if ignore_blanks?
+      def value=(v)
+        return if ignore_blanks? && v.blank?
+        self.explicitly_set_value = true
+        @value = v
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/begins_with.rb

@@ -0,0 +1,20 @@
+module Searchgasm
+  module Condition
+    class BeginsWith < Base
+      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
+end

data/lib/searchgasm/condition/child_of.rb

@@ -0,0 +1,11 @@
+module Searchgasm
+  module Condition
+    class ChildOf < Tree
+      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
+end

data/lib/searchgasm/condition/contains.rb

@@ -0,0 +1,20 @@
+module Searchgasm
+  module Condition
+    class Contains < Base
+      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
+end

data/lib/searchgasm/condition/descendant_of.rb

@@ -0,0 +1,24 @@
+module Searchgasm
+  module Condition
+    class DescendantOf < Tree
+      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
+end

data/lib/searchgasm/condition/does_not_equal.rb

@@ -0,0 +1,28 @@
+module Searchgasm
+  module Condition
+    class DoesNotEqual < Base
+      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 = Equals.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
+end

data/lib/searchgasm/condition/ends_with.rb

@@ -0,0 +1,20 @@
+module Searchgasm
+  module Condition
+    class EndsWith < Base
+      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
+end

data/lib/searchgasm/condition/equals.rb

@@ -0,0 +1,20 @@
+module Searchgasm
+  module Condition
+    class Equals < Base
+      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
+end

data/lib/searchgasm/condition/greater_than.rb

@@ -0,0 +1,25 @@
+module Searchgasm
+  module Condition
+    class GreaterThan < Base
+      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
+end

data/lib/searchgasm/condition/greater_than_or_equal_to.rb

@@ -0,0 +1,20 @@
+module Searchgasm
+  module Condition
+    class GreaterThanOrEqualTo < Base
+      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
+end

data/lib/searchgasm/condition/inclusive_descendant_of.rb

@@ -0,0 +1,13 @@
+module Searchgasm
+  module Condition
+    class InclusiveDescendantOf < Tree
+      include Searchgasm::Utilities
+      
+      def to_conditions(value)
+        condition = DescendantOf.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
+end

data/lib/searchgasm/condition/keywords.rb

@@ -0,0 +1,33 @@
+module Searchgasm
+  module Condition
+    class Keywords < Base
+      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? }
+        return if search_parts.blank?
+        
+        search_parts.each do |search_part|
+          strs << "#{quoted_table_name}.#{quoted_column_name} LIKE ?"
+          subs << "%#{search_part}%"
+        end
+        
+        [strs.join(" AND "), *subs]
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/less_than.rb

@@ -0,0 +1,25 @@
+module Searchgasm
+  module Condition
+    class LessThan < Base
+      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
+end

data/lib/searchgasm/condition/less_than_or_equal_to.rb

@@ -0,0 +1,20 @@
+module Searchgasm
+  module Condition
+    class LessThanOrEqualTo < Base
+      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
+end

data/lib/searchgasm/condition/sibling_of.rb

@@ -0,0 +1,16 @@
+module Searchgasm
+  module Condition
+    class SiblingOf < Tree
+      include Searchgasm::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 = ChildOf.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
+end

data/lib/searchgasm/condition/tree.rb

@@ -0,0 +1,16 @@
+module Searchgasm
+  module Condition
+    class Tree < Base # :nodoc:
+      class << self
+        def name_for_column(column)
+          nil
+        end
+        
+        def name_for_klass(klass)
+          return unless klass.reflect_on_association(:parent) && klass.reflect_on_association(:children)
+          condition_name
+        end
+      end
+    end
+  end
+end