searchlogic 1.5.3

data/lib/searchlogic/condition/descendant_of.rb

@@ -0,0 +1,24 @@
+module Searchlogic
+  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/searchlogic/condition/ends_with.rb

@@ -0,0 +1,17 @@
+module Searchlogic
+  module Condition
+    class EndsWith < Base
+      self.join_arrays_with_or = true
+      
+      class << self
+        def condition_names_for_column
+          super + ["ew", "ends", "end"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} LIKE ?", "%#{value}"]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/equals.rb

@@ -0,0 +1,27 @@
+module Searchlogic
+  module Condition
+    class Equals < Base
+      self.handle_array_value = true
+      self.ignore_meaningless_value = false
+      
+      class << self
+        def condition_names_for_column
+          super + ["", "is"]
+        end
+      end
+      
+      def to_conditions(value)
+        # Let ActiveRecord handle this
+        args = []
+        case value
+        when Range
+          args = [value.first, value.last]
+        else
+          args << value
+        end
+                        
+        ["#{column_sql} #{klass.send(:attribute_condition, value)}", *args]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/greater_than.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Condition
+    class GreaterThan < Base
+      class << self
+        def condition_names_for_column
+          super + ["gt", "after"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} > ?", value]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/greater_than_or_equal_to.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Condition
+    class GreaterThanOrEqualTo < Base
+      class << self
+        def condition_names_for_column
+          super + ["gte", "at_least", "least"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} >= ?", value]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/inclusive_descendant_of.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module Condition
+    class InclusiveDescendantOf < Tree      
+      def to_conditions(value)
+        condition = DescendantOf.new(klass, options)
+        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/searchlogic/condition/keywords.rb

@@ -0,0 +1,47 @@
+module Searchlogic
+  module Condition
+    class Keywords < Base
+      # Because be default it joins with AND, so padding an array just gives you more options. Joining with and is no different than combining all of the words.
+      self.join_arrays_with_or = true
+      
+      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        
+      FOREIGN_CHARACTERS = 'àáâãäåßéèêëìíîïñòóôõöùúûüýÿ'
+      
+      class << self
+        def condition_names_for_column
+          super + ["kwords", "kw"]
+        end
+      end
+      
+      def to_conditions(value)
+        strs = []
+        subs = []
+        
+        search_parts = value.gsub(/,/, " ").split(/ /)
+        replace_non_alnum_characters!(search_parts)
+        search_parts.uniq!
+        remove_blacklisted_words!(search_parts)
+        return if search_parts.blank?
+        
+        search_parts.each do |search_part|
+          strs << "#{column_sql} #{like_condition_name} ?"
+          subs << "%#{search_part}%"
+        end
+        
+        [strs.join(" AND "), *subs]
+      end
+      
+      private
+        def replace_non_alnum_characters!(search_parts)
+          search_parts.each do |word|
+            word.downcase!
+            word.gsub!(/[^[:alnum:]#{FOREIGN_CHARACTERS}]/, '')
+          end
+        end
+        
+        def remove_blacklisted_words!(search_parts)
+          search_parts.delete_if { |word| word.blank? || BLACKLISTED_WORDS.include?(word.downcase) }
+        end
+    end
+  end
+end

data/lib/searchlogic/condition/less_than.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Condition
+    class LessThan < Base
+      class << self
+        def condition_names_for_column
+          super + ["lt", "before"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} < ?", value]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/less_than_or_equal_to.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Condition
+    class LessThanOrEqualTo < Base
+      class << self
+        def condition_names_for_column
+          super + ["lte", "at_most", "most"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} <= ?", value]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/like.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Condition
+    class Like < Base
+      class << self
+        def condition_names_for_column
+          super + ["contains", "has"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} #{like_condition_name} ?", "%#{value}%"]
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/nil.rb

@@ -0,0 +1,21 @@
+module Searchlogic
+  module Condition
+    class Nil < Base
+      self.value_type = :boolean
+      
+      class << self
+        def condition_names_for_column
+          super + ["is_nil", "is_null", "null"]
+        end
+      end
+      
+      def to_conditions(value)
+        if value == true
+          "#{column_sql} IS NULL"
+        elsif value == false
+          "#{column_sql} IS NOT NULL"
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_begin_with.rb

@@ -0,0 +1,20 @@
+module Searchlogic
+  module Condition
+    class NotBeginWith < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_bw", "not_sw", "not_start_with", "not_start", "beginning_is_not", "beginning_not"]
+        end
+      end
+      
+      def to_conditions(value)
+        begin_with = BeginWith.new(klass, options)
+        begin_with.value = value
+        conditions = being_with.sanitize
+        return conditions if conditions.blank?
+        conditions.first.gsub!(" LIKE ", " NOT LIKE ")
+        conditions
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_blank.rb

@@ -0,0 +1,19 @@
+module Searchlogic
+  module Condition
+    class NotBlank < Base
+      self.value_type = :boolean
+      
+      class << self
+        def condition_names_for_column
+          super + ["is_not_blank"]
+        end
+      end
+      
+      def to_conditions(value)
+        blank = Blank.new(klass, options)
+        blank.value = !value
+        blank.sanitize
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_end_with.rb

@@ -0,0 +1,20 @@
+module Searchlogic
+  module Condition
+    class NotEndWith < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_ew", "not_end", "end_is_not", "end_not"]
+        end
+      end
+      
+      def to_conditions(value)
+        ends_with = EndsWith.new(klass, options)
+        ends_with.value = value
+        conditions = ends_with.sanitize
+        return conditions if conditions.blank?
+        conditions.first.gsub!(" LIKE ", " NOT LIKE ")
+        conditions
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_equal.rb

@@ -0,0 +1,26 @@
+module Searchlogic
+  module Condition
+    class NotEqual < Base
+      self.handle_array_value = true
+      self.ignore_meaningless_value = false
+      
+      class << self
+        def condition_names_for_column
+          super + ["does_not_equal", "not_equal", "is_not", "not"]
+        end
+      end
+      
+      def to_conditions(value)
+        # Delegate to equals and then change
+        condition = Equals.new(klass, options)
+        condition.value = value
+        conditions_array = condition.sanitize
+        conditions_array.first.gsub!(/ IS /, " IS NOT ")
+        conditions_array.first.gsub!(/ BETWEEN /, " NOT BETWEEN ")
+        conditions_array.first.gsub!(/ IN /, " NOT IN ")
+        conditions_array.first.gsub!(/=/, "!=")
+        conditions_array
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_have_keywords.rb

@@ -0,0 +1,20 @@
+module Searchlogic
+  module Condition
+    class NotHaveKeywords < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_have_keywords", "not_keywords", "not_have_kw", "not_kw", "not_have_kwwords", "not_kwwords"]
+        end
+      end
+      
+      def to_conditions(value)
+        keywords = Keywords.new(klass, options)
+        keywords.value = value
+        conditions = keywords.sanitize
+        return conditions if conditions.blank?
+        conditions.first.gsub!(" #{like_condition_name} ", " NOT #{like_condition_name} ")
+        conditions
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_like.rb

@@ -0,0 +1,20 @@
+module Searchlogic
+  module Condition
+    class NotLike < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_contain", "not_have"]
+        end
+      end
+      
+      def to_conditions(value)
+        like = Like.new(klass, options)
+        like.value = value
+        conditions = like.sanitize
+        return conditions if conditions.blank?
+        conditions.first.gsub!(" #{like_condition_name} ", " NOT #{like_condition_name} ")
+        conditions
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/not_nil.rb

@@ -0,0 +1,19 @@
+module Searchlogic
+  module Condition
+    class NotNil < Base
+      self.value_type = :boolean
+      
+      class << self
+        def condition_names_for_column
+          super + ["is_not_nil", "is_not_null", "not_null"]
+        end
+      end
+      
+      def to_conditions(value)
+        is_nil = Nil.new(klass, options)
+        is_nil.value = !value
+        is_nil.sanitize
+      end
+    end
+  end
+end

data/lib/searchlogic/condition/sibling_of.rb

@@ -0,0 +1,14 @@
+module Searchlogic
+  module Condition
+    class SiblingOf < Tree
+      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, options)
+        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/searchlogic/condition/tree.rb

@@ -0,0 +1,17 @@
+module Searchlogic
+  module Condition
+    class Tree < Base # :nodoc:
+      self.join_arrays_with_or = true
+      
+      class << self
+        def condition_names_for_column
+          []
+        end
+        
+        def condition_names_for_model(model)
+          [condition_type_name]
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/conditions/base.rb

@@ -0,0 +1,484 @@
+module Searchlogic
+  module Conditions # :nodoc:
+    # = Conditions
+    #
+    # Represents a collection of conditions and performs various tasks on that collection. For information on each condition see Searchlogic::Condition.
+    # Each condition has its own file and class and the source for each condition is pretty self explanatory.
+    class Base
+      include Shared::Utilities
+      include Shared::VirtualClasses
+      
+      attr_accessor :any, :relationship_name
+      
+      class << self
+        attr_accessor :added_klass_conditions, :added_column_equals_conditions, :added_associations
+        
+        def column_details # :nodoc:
+          return @column_details if @column_details
+          
+          @column_details = []
+          
+          klass.columns.each do |column|
+            column_detail = {:column => column}
+            column_detail[:aliases] = case column.type
+            when :datetime, :time, :timestamp
+              [column.name.gsub(/_at$/, "")]
+            when :date
+              [column.name.gsub(/_at$/, "")]
+            else
+              []
+            end
+            
+            @column_details << column_detail
+          end
+          
+          @column_details
+        end
+        
+        # Registers a condition as an available condition for a column or a class. MySQL supports a "sounds like" function. I want to use it, so let's add it.
+        #
+        # === Example
+        #
+        #   # config/initializers/searchlogic.rb
+        #   # Actual function for MySQL databases only
+        #   class SoundsLike < Searchlogic::Condition::Base
+        #     # The name of the conditions. By default its the name of the class, if you want alternate or alias conditions just add them on.
+        #     # If you don't want to add aliases you don't even need to define this method
+        #     def self.name_for_column(column)
+        #       super
+        #     end
+        #
+        #     # You can return an array or a string. NOT a hash, because all of these conditions
+        #     # need to eventually get merged together. The array or string can be anything you would put in
+        #     # the :conditions option for ActiveRecord::Base.find(). Also notice the column_sql variable. This is essentail
+        #     # for applying modifiers and should be used in your conditions wherever you want the column.
+        #     def to_conditions(value)
+        #       ["#{column_sql} SOUNDS LIKE ?", value]
+        #     end
+        #   end
+        #
+        #   Searchlogic::Seearch::Conditions.register_condition(SoundsLike)
+        def register_condition(condition_class)
+          raise(ArgumentError, "You can only register conditions that extend Searchlogic::Condition::Base") unless condition_class.ancestors.include?(Searchlogic::Condition::Base)
+          conditions << condition_class unless conditions.include?(condition_class)
+        end
+        
+        # A list of available condition type classes
+        def conditions
+          @@conditions ||= []
+        end
+        
+        # Registers a modifier as an available modifier for each column.
+        #
+        # === Example
+        #
+        #   # config/initializers/searchlogic.rb
+        #   class Ceil < Searchlogic::Modifiers::Base
+        #     # The name of the modifier. By default its the name of the class, if you want alternate or alias modifiers just add them on.
+        #     # If you don't want to add aliases you don't even need to define this method
+        #     def self.modifier_names
+        #       super + ["round_up"]
+        #     end
+        #
+        #     # The name of the method in the connection adapters (see below). By default its the name of your class suffixed with "_sql".
+        #     # So in this example it would be "ceil_sql". Unless you want to change that you don't need to define this method.
+        #     def self.adapter_method_name
+        #       super
+        #     end
+        #
+        #     # This is the type of value returned from the modifier. This is neccessary for typcasting values for the modifier when
+        #     # applied to a column
+        #     def self.return_type
+        #       :integer
+        #     end
+        #   end
+        #
+        #   Searchlogic::Seearch::Conditions.register_modifiers(Ceil)
+        #
+        # Now here's the fun part, applying this modifier to each connection adapter. Some databases call modifiers differently. If they all apply them the same you can
+        # add in the function to ActiveRecord::ConnectionAdapters::AbstractAdapter, otherwise you need to add them to each
+        # individually: ActiveRecord::ConnectionAdapters::MysqlAdapter, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter, ActiveRecord::ConnectionAdapters::SQLiteAdapter
+        #
+        # Do this by includine a model with your method. The name of your method, by default, is: #{modifier_name}_sql. So in the example above it would be "ceil_sql"
+        #
+        #   module CeilAdapterMethod
+        #     def ceil_sql(column_name)
+        #       "CEIL(#{column_name})"
+        #     end
+        #   end
+        #
+        #   ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, CeilAdapterMethod)
+        #   # ... include for the rest of the adapters
+        def register_modifier(modifier_class)
+          raise(ArgumentError, "You can only register conditions that extend Searchlogic::Modifiers::Base") unless modifier_class.ancestors.include?(Searchlogic::Modifiers::Base)
+          modifiers << modifier_class unless modifiers.include?(modifier_class)
+        end
+        
+        # A list of available modifier classes
+        def modifiers
+          @@modifiers ||= []
+        end
+        
+        # A list of all associations created, used for caching and performance
+        def association_names
+          @association_names ||= []
+        end
+        
+        # A list of all conditions available, users for caching and performance
+        def condition_names
+          @condition_names ||= []
+        end
+        
+        def needed?(model_class, conditions) # :nodoc:
+          return false if conditions.blank?
+          
+          if conditions.is_a?(Hash)
+            return true if conditions[:any]
+            stringified_conditions = conditions.stringify_keys
+            stringified_conditions.keys.each { |condition| return false if condition.include?(".") } # setting conditions on associations, which is just another way of writing SQL, and we ignore SQL
+            
+            column_names = model_class.column_names
+            stringified_conditions.keys.each do |condition|
+              return true unless column_names.include?(condition)
+            end
+          end
+          
+          false
+        end
+      end
+      
+      def initialize(init_conditions = {})
+        add_associations!
+        add_column_equals_conditions!
+        self.conditions = init_conditions
+      end
+      
+      # Determines if we should join the conditions with "AND" or "OR".
+      #
+      # === Examples
+      #
+      #   search.conditions.any = true # will join all conditions with "or", you can also set this to "true", "1", or "yes"
+      #   search.conditions.any = false # will join all conditions with "and"
+      def any=(value)
+        associations.each { |name, association| association.any = value }
+        @any = value
+      end
+      
+      def any # :nodoc:
+        any?
+      end
+      
+      # Convenience method for determining if we should join the conditions with "AND" or "OR".
+      def any?
+        @any == true || @any == "true" || @any == "1" || @any == "yes"
+      end
+      
+      # A list of joins to use when searching, includes relationships
+      def auto_joins
+        j = []
+        associations.each do |name, association|
+          next if association.conditions.blank?
+          association_joins = association.auto_joins
+          j << (association_joins.blank? ? name : {name => association_joins})
+        end
+        j.blank? ? nil : (j.size == 1 ? j.first : j)
+      end
+      
+      def inspect
+        "#<#{klass}Conditions#{conditions.blank? ? "" : " #{conditions.inspect}"}>"
+      end
+      
+      # Sanitizes the conditions down into conditions that ActiveRecord::Base.find can understand.
+      def sanitize
+        return @conditions if @conditions
+        merge_conditions(*(objects.collect { |name, object| object.sanitize } << {:any => any}))
+      end
+      
+      # Allows you to set the conditions via a hash.
+      def conditions=(value)
+        case value
+        when Hash
+          assert_valid_conditions(value)
+          remove_conditions_from_protected_assignement(value).each do |condition, condition_value|
+            
+            # delete all blanks from mass assignments, forms submit blanks, blanks are meaningless
+            # equals condition thinks everything is meaningful, and arrays can be pased
+            new_condition_value = nil
+            case condition_value
+            when Array
+              new_condition_value = []
+              condition_value.each { |v| new_condition_value << v unless v == "" }
+              next if new_condition_value.size == 0
+              new_condition_value = new_condition_value.first if new_condition_value.size == 1
+            else
+              next if condition_value == ""
+              new_condition_value = condition_value
+            end
+            
+            send("#{condition}=", new_condition_value)
+          end
+        else
+          reset_objects!
+          @conditions = value
+        end
+      end
+      
+      # All of the active conditions (conditions that have been set)
+      def conditions
+        return @conditions if @conditions
+        return if objects.blank?
+        
+        conditions_hash = {}
+        objects.each do |name, object|
+          if object.class < Searchlogic::Conditions::Base
+            relationship_conditions = object.conditions
+            next if relationship_conditions.blank?
+            conditions_hash[name] = relationship_conditions
+          else
+            next if object.value_is_meaningless?
+            conditions_hash[name] = object.value
+          end
+        end
+        conditions_hash
+      end
+      
+      private
+        def add_associations!
+          return true if self.class.added_associations
+          
+          klass.reflect_on_all_associations.each do |association|
+            self.class.association_names << association.name.to_s
+            
+            self.class.class_eval <<-"end_eval", __FILE__, __LINE__
+              def #{association.name}
+                if objects[:#{association.name}].nil?
+                  objects[:#{association.name}] = Searchlogic::Conditions::Base.create_virtual_class(#{association.class_name}).new
+                  objects[:#{association.name}].relationship_name = "#{association.name}"
+                  objects[:#{association.name}].protect = protect
+                end
+                objects[:#{association.name}]
+              end
+            
+              def #{association.name}=(conditions); @conditions = nil; #{association.name}.conditions = conditions; end
+              def reset_#{association.name}!; objects.delete(:#{association.name}); end
+            end_eval
+          end
+          
+          self.class.added_associations = true
+        end
+        
+        def add_column_equals_conditions!
+          return true if self.class.added_column_equals_conditions
+          klass.column_names.each { |name| setup_condition(name) }
+          self.class.added_column_equals_conditions = true
+        end
+        
+        def extract_column_and_condition_from_method_name(name)
+          name_parts = name.gsub("=", "").split("_")
+          
+          condition_parts = []
+          column = nil
+          while column.nil? && name_parts.size > 0
+            possible_column_name = name_parts.join("_")
+            
+            self.class.column_details.each do |column_detail|
+              if column_detail[:column].name == possible_column_name || column_detail[:aliases].include?(possible_column_name)
+                column = column_detail
+                break
+              end
+            end
+            
+            condition_parts << name_parts.pop if !column
+          end
+          
+          return if column.nil?
+          
+          condition_name = condition_parts.reverse.join("_")
+          condition = nil
+          
+          # Find the real condition
+          self.class.conditions.each do |condition_klass|
+            if condition_klass.condition_names_for_column.include?(condition_name)
+              condition = condition_klass
+              break
+            end
+          end
+                                         
+          [column, condition]
+        end
+        
+        def breakdown_method_name(name)
+          column_detail, condition_klass = extract_column_and_condition_from_method_name(name)
+          if !column_detail.nil? && !condition_klass.nil?
+            # There were no modifiers
+            return [[], column_detail, condition_klass]
+          else
+            # There might be modifiers
+            name_parts = name.split("_of_")
+            column_detail, condition_klass = extract_column_and_condition_from_method_name(name_parts.pop)
+            if !column_detail.nil? && !condition_klass.nil?
+              # There were modifiers, lets get their real names
+              modifier_klasses = []
+              name_parts.each do |modifier_name|
+                size_before = modifier_klasses.size
+                self.class.modifiers.each do |modifier_klass|
+                  if modifier_klass.modifier_names.include?(modifier_name)
+                    modifier_klasses << modifier_klass
+                    break
+                  end
+                end
+                return if modifier_klasses.size == size_before # there was an invalid modifer, return nil for everything and let it act as a nomethoderror
+              end
+              
+              return [modifier_klasses, column_detail, condition_klass]
+            end
+          end
+          
+          nil
+        end
+        
+        def build_method_name(modifier_klasses, column_name, condition_name)
+          modifier_name_parts = []
+          modifier_klasses.each { |modifier_klass| modifier_name_parts << modifier_klass.modifier_names.first }
+          method_name_parts = []
+          method_name_parts << modifier_name_parts.join("_of_") + "_of" unless modifier_name_parts.blank?
+          method_name_parts << column_name
+          method_name_parts << condition_name unless condition_name.blank?
+          method_name_parts.join("_")
+        end
+        
+        def method_missing(name, *args, &block)
+          if setup_condition(name)
+            send(name, *args, &block)
+          else
+            super
+          end
+        end
+        
+        def setup_condition(name)
+          modifier_klasses, column_detail, condition_klass = breakdown_method_name(name.to_s)
+          if !column_detail.nil? && !condition_klass.nil?
+            method_name = build_method_name(modifier_klasses, column_detail[:column].name, condition_klass.condition_names_for_column.first)
+            
+            if !added_condition?(method_name)
+              column_type = column_sql = nil
+              if !modifier_klasses.blank?
+                # Find the column type
+                column_type = modifier_klasses.first.return_type
+              
+                # Build the column sql
+                column_sql = "{table}.{column}"
+                modifier_klasses.each do |modifier_klass|
+                  next unless klass.connection.respond_to?(modifier_klass.adapter_method_name)
+                  column_sql = klass.connection.send(modifier_klass.adapter_method_name, column_sql)
+                end
+              end
+            
+              add_condition!(condition_klass, method_name, :column => column_detail[:column], :column_type => column_type, :column_sql_format => column_sql)
+            
+              ([column_detail[:column].name] + column_detail[:aliases]).each do |column_name|
+                condition_klass.condition_names_for_column.each do |condition_name|
+                  alias_method_name = build_method_name(modifier_klasses, column_name, condition_name)
+                  add_condition_alias!(alias_method_name, method_name) unless added_condition?(alias_method_name)
+                end
+              end
+            end
+            
+            alias_method_name = name.to_s.gsub("=", "")
+            add_condition_alias!(alias_method_name, method_name) unless added_condition?(alias_method_name)
+            
+            return true
+          end
+          
+          false
+        end
+        
+        def add_condition!(condition, name, options = {})
+          self.class.condition_names << name
+          options[:column] = options[:column].name if options[:column].class < ::ActiveRecord::ConnectionAdapters::Column
+          
+          self.class.class_eval <<-"end_eval", __FILE__, __LINE__
+            def #{name}_object
+              if objects[:#{name}].nil?
+                options = {}
+                objects[:#{name}] = #{condition.name}.new(klass, #{options.inspect})
+              end
+              objects[:#{name}]
+            end
+
+            def #{name}; #{name}_object.value; end
+            
+            def #{name}=(value)
+              @conditions = nil
+              
+              #{name}_object.value = value
+              reset_#{name}! if #{name}_object.value_is_meaningless?
+              value
+            end
+            
+            def reset_#{name}!; objects.delete(:#{name}); end
+          end_eval
+        end
+        
+        def added_condition?(name)
+          respond_to?("#{name}_object") && respond_to?(name) && respond_to?("#{name}=") && respond_to?("reset_#{name}!")
+        end
+        
+        def add_condition_alias!(alias_name, name)
+          self.class.condition_names << alias_name
+          
+          self.class.class_eval do
+            alias_method "#{alias_name}_object", "#{name}_object"
+            alias_method alias_name, name
+            alias_method "#{alias_name}=", "#{name}="
+            alias_method "reset_#{alias_name}!", "reset_#{name}!"
+          end
+        end
+        
+        def assert_valid_conditions(conditions)
+          conditions.each do |condition, value|
+            next if (self.class.condition_names + self.class.association_names + ["any"]).include?(condition.to_s)
+            
+            go_to_next = false
+            self.class.column_details.each do |column_detail|
+              if column_detail[:column].name == condition.to_s || column_detail[:aliases].include?(condition.to_s)
+                go_to_next = true
+                break
+              end
+            end
+            next if go_to_next
+            
+            next unless respond_to?(condition)
+            
+            raise(ArgumentError, "The #{condition} condition is not a valid condition")
+          end
+        end
+        
+        def associations
+          associations = {}
+          objects.each do |name, object|
+            associations[name] = object if object.class < ::Searchlogic::Conditions::Base
+          end
+          associations
+        end
+        
+        def objects
+          @objects ||= {}
+        end
+        
+        def reset_objects!
+          objects.each { |name, object| eval("@#{name} = nil") }
+          objects.clear
+        end
+        
+        def remove_conditions_from_protected_assignement(conditions)
+          return conditions if klass.accessible_conditions.nil? && klass.protected_conditions.nil?
+          if klass.accessible_conditions
+            conditions.reject { |condition, value| !klass.accessible_conditions.include?(condition.to_s) }
+          elsif klass.protected_conditions
+            conditions.reject { |condition, value| klass.protected_conditions.include?(condition.to_s) }
+          end
+        end
+    end
+  end
+end