schof-searchlogic 0.0.2

data/lib/searchlogic/conditions/base.rb

@@ -0,0 +1,244 @@
+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 :object_name
+      
+      class << self
+        # 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.condition_names_for_column
+        #       super + ["similar_to", "sounds"]
+        #     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::Conditions::Base.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
+        
+        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
+      
+      # Initializes a conditions object, accepts a hash of conditions as the single parameter
+      def initialize(init_conditions = {})
+        self.conditions = init_conditions
+      end
+      
+      # A list of joins to use when searching, includes relationships
+      def auto_joins
+        j = []
+        association_objects.each do |association|
+          next if association.conditions.blank?
+          association_joins = association.auto_joins
+          j << (association_joins.blank? ? association.object_name : {association.object_name => association_joins})
+        end
+        j.blank? ? nil : (j.size == 1 ? j.first : j)
+      end
+      
+      # Provides a much more informative and easier to understand inspection of the object
+      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 # return the conditions if the user set them with a string, aka sql conditions
+        joined_conditions = nil
+        objects.each do |object|
+          sanitized_conditions = group?(object) ? scope_condition(object.sanitize) : object.sanitize
+          joined_conditions = merge_conditions(joined_conditions, sanitized_conditions, :any => join_object_with_any?(object))
+        end
+        joined_conditions
+      end
+      
+      # Allows you to set the conditions via a hash.
+      def conditions=(value)
+        case value
+        when Array
+          value.each { |v| self.conditions = v }
+        when Hash
+          remove_conditions_from_protected_assignement(value).each do |condition, condition_value|
+            next if [:conditions].include?(condition.to_sym) # protect sensitive methods
+            
+            # 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.reject { |v| v == "" }
+              next if new_condition_value.empty?
+              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!
+          @conditions = value
+        end
+      end
+      
+      # All of the active conditions (conditions that have been set)
+      def conditions
+        return @conditions if @conditions
+        
+        conditions_hash = {}
+        
+        association_objects.each do |association_object|
+          relationship_conditions = association_object.conditions
+          next if relationship_conditions.blank?
+          conditions_hash[association_object.object_name] = relationship_conditions
+        end
+        
+        condition_objects.each do |condition_object|
+          next if condition_object.value_is_meaningless?
+          conditions_hash[condition_object.object_name] = condition_object.value
+        end
+        
+        conditions_hash
+      end
+      
+      # Resets all of the conditions, including conditions set on associations
+      def reset!
+        objects.each { |object| eval("@#{object.object_name} = nil") }
+        objects.clear
+      end
+      
+      private
+        def association_objects
+          objects.select { |object| association?(object) }
+        end
+        
+        def association?(object)
+          object.class < Base && object.class != self.class
+        end
+        
+        def condition_objects
+          objects.select { |object| condition?(object) }
+        end
+        
+        def condition?(object)
+          object.class < Condition::Base
+        end
+        
+        def objects
+          @objects ||= []
+        end
+        
+        def join_object_with_any?(object)
+          return any? if !any.nil?
+          if condition?(object) || group?(object)
+            object.explicit_any?
+          elsif association?(object)
+            object.send(:join_object_with_any?, object.send(:objects).first)
+          end
+        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

data/lib/searchlogic/conditions/groups.rb

@@ -0,0 +1,74 @@
+module Searchlogic
+  module Conditions
+    # = Groups
+    #
+    # Allows you to group conditions, similar to how you would group conditions with parenthesis in an SQL statement. See the "Group conditions" section in the READM for examples.
+    module Groups
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :auto_joins, :groups
+        end
+      end
+      
+      def auto_joins_with_groups
+        auto_joins = auto_joins_without_groups
+        auto_joins = auto_joins.is_a?(Array) ? auto_joins : [auto_joins].compact
+        
+        group_objects.each do |group|
+          next if group.conditions.blank?
+          group_joins = group.auto_joins
+          next if group_joins.blank?
+          group_joins = group_joins.is_a?(Array) ? group_joins : [group_joins]
+          auto_joins += group_joins
+        end
+        
+        auto_joins.blank? ? nil : (auto_joins.size == 1 ? auto_joins.first : auto_joins)
+      end
+      
+      # Creates a new group object to set condition off of. See examples at top of class on how to use this.
+      def group(conditions = nil, &block)
+        obj = self.class.new
+        obj.conditions = conditions unless conditions.nil?
+        yield obj if block_given?
+        objects << obj
+        obj
+      end
+      alias_method :group=, :group
+      
+      def and_group(*args, &block)
+        obj = group(*args, &block)
+        obj.explicit_any = false
+        obj
+      end
+      alias_method :and_group=, :and_group
+      
+      def or_group(*args, &block)
+        obj = group(*args, &block)
+        obj.explicit_any = true
+        obj
+      end
+      alias_method :or_group=, :or_group
+      
+      def explicit_any=(value) # :nodoc:
+        @explicit_any = value
+      end
+      
+      def explicit_any # :nodoc
+        @explicit_any
+      end
+      
+      def explicit_any? # :nodoc:
+        ["true", "1", "yes"].include? explicit_any.to_s
+      end
+      
+      private
+        def group_objects
+          objects.select { |object| group?(object) }
+        end
+        
+        def group?(object)
+          object.class == self.class
+        end
+    end
+  end
+end

data/lib/searchlogic/conditions/magic_methods.rb

@@ -0,0 +1,286 @@
+module Searchlogic
+  module Conditions
+    # = Magic Methods
+    #
+    # Handles all method magic, creating methods on the fly, etc. This is needed for modifiers.
+    module MagicMethods
+      def self.included(klass)
+        klass.metaclass.class_eval do
+          include ClassMethods
+          attr_accessor :added_class_level_conditions, :added_column_equals_conditions, :added_associations
+        end
+        
+        klass.class_eval do
+          include InstanceMethods
+          alias_method_chain :initialize, :magic_methods
+          alias_method_chain :method_missing, :magic_methods
+        end
+      end
+      
+      module ClassMethods # :nodoc:
+        def column_details
+          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
+      end
+      
+      module InstanceMethods # :nodoc:
+        def initialize_with_magic_methods(*args)
+          add_associations!
+          add_column_equals_conditions!
+          add_class_level_conditions!
+          initialize_without_magic_methods(*args)
+        end
+        
+        private
+          def add_associations!
+            return true if self.class.added_associations
+          
+            klass.reflect_on_all_associations.each do |association|
+              next if !association.options[:finder_sql].nil? # associations with finder_sql should not be added since conditions can not be chained to them, etc.
+              self.class.class_eval <<-"end_eval", __FILE__, __LINE__
+                def #{association.name}
+                  return @#{association.name} unless @#{association.name}.nil?
+                  @#{association.name} = Searchlogic::Conditions::Base.create_virtual_class(#{association.class_name}).new
+                  @#{association.name}.object_name = :#{association.name}
+                  @#{association.name}.protect = protect
+                  objects << @#{association.name}
+                  @#{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
+              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 add_class_level_conditions!
+            return true if self.class.added_class_level_conditions
+            class_level_conditions = self.class.conditions.select { |condition_class| !condition_class.condition_names_for_model.blank? }
+            class_level_conditions.each do |condition_class|
+              condition_class.condition_names_for_model.each_with_index do |condition_name, index|
+                if index == 0
+                  add_condition!(condition_class, condition_name, :column => klass.columns_hash[klass.primary_key])
+                else
+                  add_condition_alias!(condition_name, condition_class.condition_names_for_model.first)
+                end
+              end
+            end
+            self.class.added_class_level_conditions = true
+          end
+        
+          def sanitize_method_name(name)
+            name.gsub("=", "").gsub(/^(and|or)_/, "")
+          end
+        
+          def extract_column_and_condition_from_method_name(name)
+            name_parts = sanitize_method_name(name).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("_").underscore
+          end
+        
+          def method_missing_with_magic_methods(name, *args, &block)
+            if setup_condition(name)
+              send(name, *args, &block)
+            else
+              method_missing_without_magic_methods(name, *args, &block)
+            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 = sanitize_method_name(name.to_s)
+              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 = {})
+            options[:column] = options[:column].name if options[:column]
+          
+            self.class.class_eval <<-"end_eval", __FILE__, __LINE__
+              def #{name}_object
+                return @#{name} unless @#{name}.nil?
+                @#{name} = #{condition.name}.new(klass, #{options.inspect})
+                @#{name}.object_name = :#{name}
+                objects << @#{name}
+                @#{name}
+              end
+            
+              def #{name}
+                #{name}_object.value
+              end
+              alias_method :and_#{name}, :#{name}
+              alias_method :or_#{name}, :#{name}
+            
+              def #{name}=(value)
+                @conditions = nil
+                #{name}_object.value = value
+                value
+              end
+            
+              def and_#{name}=(value)
+                #{name}_object.explicit_any = false
+                self.#{name} = value
+              end
+            
+              def or_#{name}=(value)
+                #{name}_object.explicit_any = true
+                self.#{name} = value
+              end
+            
+              def reset_#{name}!
+                objects.delete(#{name}_object)
+                @#{name} = nil
+              end
+            end_eval
+          end
+        
+          def added_condition?(name)
+            respond_to?("#{name}_object")
+          end
+        
+          def add_condition_alias!(alias_name, 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 "and_#{alias_name}=", "and_#{name}="
+              alias_method "or_#{alias_name}=", "or_#{name}="
+              alias_method "reset_#{alias_name}!", "reset_#{name}!"
+            end
+          end
+      end
+    end
+  end
+end