searchgasm 1.2.2 → 1.3.0

data/lib/searchgasm/conditions/base.rb

@@ -13,36 +13,51 @@ module Searchgasm
       class << self
         attr_accessor :added_klass_conditions, :added_column_conditions, :added_associations
         
-        # Registers a condition as an available condition for a column or a class.
+        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/searchgasm.rb
+        #   # config/initializers/searchgasm.rb
         #   # Actual function for MySQL databases only
         #   class SoundsLike < Searchgasm::Condition::Base
-        #     class << self
-        #       # I pass you the column, you tell me what you want the method to be called.
-        #       # If you don't want to add this condition for that column, return nil
-        #       # It defaults to "#{column.name}_sounds_like" (using the class name). So if thats what you want you don't even need to do this.
-        #       def name_for_column(column)
-        #         super
-        #       end
-        #
-        #       # Only do this if you want aliases for your condition
-        #       def aliases_for_column(column)
-        #         ["#{column.name}_sounds", "#{column.name}_similar_to"]
-        #       end
+        #     # 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, for a list of methods / variables you can use check out earchgasm::Condition::Base
+        #     # 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)
-        #       ["#{quoted_table_name}.#{quoted_column_name} SOUNDS LIKE ?", value]
+        #       ["#{column_sql} SOUNDS LIKE ?", value]
         #     end
         #   end
         #
-        #   Searchgasm::Seearch::Conditions.register_condition(SoundsLikeCondition)
+        #   Searchgasm::Seearch::Conditions.register_condition(SoundsLike)
         def register_condition(condition_class)
           raise(ArgumentError, "You can only register conditions that extend Searchgasm::Condition::Base") unless condition_class.ancestors.include?(Searchgasm::Condition::Base)
           conditions << condition_class unless conditions.include?(condition_class)
@@ -53,6 +68,57 @@ module Searchgasm
           @@conditions ||= []
         end
         
+        # Registers a modifier as an available modifier for each column.
+        #
+        # === Example
+        #
+        #   # config/initializers/searchgasm.rb
+        #   class Ceil < Searchgasm::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
+        #
+        #   Searchgasm::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 Searchgasm::Modifiers::Base") unless modifier_class.ancestors.include?(Searchgasm::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 ||= []
@@ -82,8 +148,6 @@ module Searchgasm
       end
       
       def initialize(init_conditions = {})
-        add_klass_conditions!
-        add_column_conditions!
         add_associations!
         self.conditions = init_conditions
       end
@@ -95,7 +159,7 @@ module Searchgasm
       #   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 { |association| association.any = value }
+        associations.each { |name, association| association.any = value }
         @any = value
       end
       
@@ -111,7 +175,7 @@ module Searchgasm
       # A list of joins to use when searching, includes relationships
       def auto_joins
         j = []
-        associations.each do |association|
+        associations.each do |name, association|
           next if association.conditions.blank?
           association_joins = association.auto_joins
           j << (association_joins.blank? ? association.relationship_name.to_sym : {association.relationship_name.to_sym => association_joins})
@@ -126,16 +190,15 @@ module Searchgasm
       # Sanitizes the conditions down into conditions that ActiveRecord::Base.find can understand.
       def sanitize
         return @conditions if @conditions
-        merge_conditions(*(objects.collect { |object| object.sanitize } << {:any => any}))
+        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          
+        when Hash
           assert_valid_conditions(value)
           remove_conditions_from_protected_assignement(value).each do |condition, condition_value|
-            next if meaningless?(condition_value) # ignore blanks on mass assignments
             send("#{condition}=", condition_value)
           end
         else
@@ -150,14 +213,14 @@ module Searchgasm
         return if objects.blank?
         
         conditions_hash = {}
-        objects.each do |object|
+        objects.each do |name, object|
           if object.class < Searchgasm::Conditions::Base
             relationship_conditions = object.conditions
             next if relationship_conditions.blank?
             conditions_hash[object.relationship_name.to_sym] = relationship_conditions
           else
-            next unless object.explicitly_set_value?
-            conditions_hash[object.name.to_sym] = object.value
+            next if object.meaningless_value?
+            conditions_hash[name] = object.value
           end
         end
         conditions_hash
@@ -172,62 +235,150 @@ module Searchgasm
             
             self.class.class_eval <<-"end_eval", __FILE__, __LINE__
               def #{association.name}
-                if @#{association.name}.nil?
-                  @#{association.name} = Searchgasm::Conditions::Base.create_virtual_class(#{association.class_name}).new
-                  @#{association.name}.relationship_name = "#{association.name}"
-                  @#{association.name}.protect = protect
-                  objects << @#{association.name}
+                if objects[:#{association.name}].nil?
+                  objects[:#{association.name}] = Searchgasm::Conditions::Base.create_virtual_class(#{association.class_name}).new
+                  objects[:#{association.name}].relationship_name = "#{association.name}"
+                  objects[:#{association.name}].protect = protect
                 end
-                @#{association.name}
+                objects[:#{association.name}]
               end
             
               def #{association.name}=(conditions); @conditions = nil; #{association.name}.conditions = conditions; end
-              def reset_#{association.name}!; objects.delete(#{association.name}); @#{association.name} = nil; end
+              def reset_#{association.name}!; objects.delete(:#{association.name}); end
             end_eval
           end
           
           self.class.added_associations = true
         end
         
-        def add_column_conditions!
-          return true if self.class.added_column_conditions
+        def extract_column_and_condition_from_method_name(name)
+          name_parts = name.gsub("=", "").split("_")
           
-          klass.columns.each do |column|
-            self.class.conditions.each do |condition_klass|
-              name = condition_klass.name_for_column(column)
-              next if name.blank?
-              add_condition!(condition_klass, name, column)
-              condition_klass.aliases_for_column(column).each { |alias_name| add_condition_alias!(alias_name, name) }
+          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
           
-          self.class.added_column_conditions = true
+          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 add_condition!(condition, name, column = nil)
+        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_") unless modifier_name_parts.blank?
+          method_name_parts << column_name
+          method_name_parts << condition_name
+          method_name_parts.join("_")
+        end
+        
+        def method_missing(name, *args, &block)
+          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)
+            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 = "#{klass.connection.quote_table_name(klass.table_name)}.#{klass.connection.quote_column_name(column_detail[:column].name)}"
+              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_detail[:column], column_type, 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 alias_method_name == method_name
+              end
+            end
+            
+            send(method_name + (name.to_s =~ /=$/ ? "=" : ""), *args, &block)
+          else
+            super
+          end
+        end
+        
+        def add_condition!(condition, name, column = nil, column_type = nil, column_sql = nil)
           self.class.condition_names << name
           
           self.class.class_eval <<-"end_eval", __FILE__, __LINE__
             def #{name}_object
-              if @#{name}.nil?
-                @#{name} = #{condition.name}.new(klass#{column.nil? ? "" : ", \"#{column.name}\""})
-                objects << @#{name}
+              if objects[:#{name}].nil?
+                objects[:#{name}] = #{condition.name}.new(klass, #{column.blank? ? "nil" : "klass.columns_hash['#{column.name}']"}, #{column_type.blank? ? "nil" : "\"#{column_type}\""}, #{column_sql.blank? ? "nil" : "\"#{column_sql.gsub('"', '\"')}\""})
               end
-              @#{name}
+              objects[:#{name}]
             end
 
             def #{name}; #{name}_object.value; end
             
             def #{name}=(value)
-              if meaningless?(value) && #{name}_object.class.ignore_meaningless?
-                reset_#{name}!
-              else
-                @conditions = nil
-                #{name}_object.value = value
-              end
+              @conditions = nil
+              
+              #{name}_object.value = value
+              reset_#{name}! if #{name}_object.meaningless_value?
+              value
             end
             
-            def reset_#{name}!; objects.delete(#{name}_object); @#{name} = nil; end
+            def reset_#{name}!; objects.delete(:#{name}); end
           end_eval
         end
         
@@ -235,38 +386,33 @@ module Searchgasm
           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 add_klass_conditions!
-          return true if self.class.added_klass_conditions
-          
-          self.class.conditions.each do |condition|
-            name = condition.name_for_klass(klass)
-            next if name.blank?
-            add_condition!(condition, name)
-            condition.aliases_for_klass(klass).each { |alias_name| add_condition_alias!(alias_name, name) }
-          end
-          
-          self.class.added_klass_conditions = true
-        end
-        
         def assert_valid_conditions(conditions)
-          conditions.stringify_keys.fast_assert_valid_keys(self.class.condition_names + self.class.association_names + ["any"])
+          conditions.each do |condition, value|
+            raise(ArgumentError, "The #{condition} condition is not a valid condition") if !(self.class.condition_names + self.class.association_names + ["any"]).include?(condition.to_s) && respond_to?(condition)
+          end
         end
         
         def associations
-          objects.select { |object| object.class < ::Searchgasm::Conditions::Base }
+          associations = {}
+          objects.each do |name, object|
+            associations[name] = object if object.class < ::Searchgasm::Conditions::Base
+          end
+          associations
         end
         
         def objects
-          @objects ||= []
+          @objects ||= {}
         end
         
         def reset_objects!
-          objects.each { |object| object.class < ::Searchgasm::Conditions::Base ? eval("@#{object.relationship_name} = nil") : eval("@#{object.name} = nil") }
+          objects.each { |name, object| object.class < ::Searchgasm::Conditions::Base ? eval("@#{object.relationship_name} = nil") : eval("@#{name} = nil") }
           objects.clear
         end
         

data/lib/searchgasm/modifiers/absolute.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class Absolute < Base
+      class << self
+        def modifier_names
+          super + ["abs"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/acos.rb

@@ -0,0 +1,11 @@
+module Searchgasm
+  module Modifiers
+    class Acos < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/asin.rb

@@ -0,0 +1,11 @@
+module Searchgasm
+  module Modifiers
+    class Asin < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/atan.rb

@@ -0,0 +1,11 @@
+module Searchgasm
+  module Modifiers
+    class Atan < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/base.rb

@@ -0,0 +1,27 @@
+module Searchgasm
+  module Modifiers
+    class Base
+      class << self
+        # A convenience method for the name of this modifier
+        def modifier_name
+          name.split("::").last.underscore
+        end
+        
+        # The various names for the modifier. The first in the array is the "main" name, the rest are just aliases to the "main" name
+        def modifier_names
+          [modifier_name]
+        end
+        
+        # The method in the connection adapter that creates the SQL for the modifier
+        def adapter_method_name
+          "#{modifier_name}_sql"
+        end
+        
+        # The type of value returned from the SQL. A class the extends this MUST define this method.
+        def return_type
+          raise "You did not specify a return type for the #{modifier_name} modifier. Please specify if it is an :integer, :string, etc."
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/ceil.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class Ceil < Base
+      class << self
+        def modifier_names
+          super + ["round_up"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/char_length.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class CharLength < Base
+      class << self
+        def modifier_names
+          super + ["length"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/cos.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class Cos < Base
+      class << self
+        def modifier_names
+          super + ["cosine"]
+        end
+        
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/cot.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class Cot < Base
+      class << self
+        def modifier_names
+          super + ["cotangent"]
+        end
+        
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/day_of_month.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class DayOfMonth < Base
+      class << self
+        def modifier_names
+          super + ["dom"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/day_of_week.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class DayOfWeek < Base
+      class << self
+        def modifier_names
+          super + ["dow"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/day_of_year.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class DayOfYear < Base
+      class << self
+        def modifier_names
+          super + ["doy"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/degrees.rb

@@ -0,0 +1,11 @@
+module Searchgasm
+  module Modifiers
+    class Degrees < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/exp.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class Exp < Base
+      class << self
+        def modifier_names
+          super + ["exponential"]
+        end
+        
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/floor.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Modifiers
+    class Floor < Base
+      class << self
+        def modifier_names
+          super + ["round_down"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/modifiers/hex.rb

@@ -0,0 +1,11 @@
+module Searchgasm
+  module Modifiers
+    class Hex < Base
+      class << self
+        def return_type
+          :string
+        end
+      end
+    end
+  end
+end