searchlogic 1.6.6 → 2.1.0

data/lib/searchlogic/conditions/base.rb

@@ -1,244 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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