searchlogic 1.5.4 → 1.5.6

data/lib/searchlogic/conditions/magic_methods.rb

@@ -0,0 +1,268 @@
+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_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!
+          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|
+              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 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
+          
+            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
+            
+              def #{name}=(value)
+                @conditions = nil
+                #{name}_object.value = value
+                reset_#{name}! if #{name}_object.value_is_meaningless?
+                value
+              end
+            
+              def and_#{name}=(value)
+                #{name}_object.any = false
+                self.#{name} = value
+              end
+            
+              def or_#{name}=(value)
+                #{name}_object.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

data/lib/searchlogic/conditions/protection.rb

@@ -23,7 +23,7 @@ module Searchlogic
       end
       
       def protect=(value)
-        associations.each { |name, obj| obj.protect = value }
+        association_objects.each { |obj| obj.protect = value }
         @protect = value
       end
       

data/lib/searchlogic/config/helpers.rb

@@ -31,18 +31,20 @@ module Searchlogic
         # The class name for used in the order_as_link helper
         #
         # * <tt>Default:</tt> "order_as"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def order_as_link_class_name
-          @order_as_link_class_name ||= "order_as"
+          return @order_as_link_class_name if defined?(@order_as_link_class_name)
+          @order_as_link_class_name = "order_as"
         end
         attr_writer :order_as_link_class_name
         
         # The class name for used in the order_as_select helper
         #
         # * <tt>Default:</tt> "order_as"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def order_as_select_class_name
-          @order_as_select_class_name ||= "order_as"
+          return @order_as_select_class_name if defined?(@order_as_select_class_name)
+          @order_as_select_class_name = "order_as"
         end
         attr_writer :order_as_select_class_name
         
@@ -63,9 +65,10 @@ module Searchlogic
         # The class name for used in the order_by_link helper
         #
         # * <tt>Default:</tt> "order_by"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def order_by_link_class_name
-          @order_by_link_class_name ||= "order_by"
+          return @order_by_link_class_name if defined?(@order_by_link_class_name)
+          @order_by_link_class_name = "order_by"
         end
         attr_writer :order_by_link_class_name
       
@@ -80,9 +83,10 @@ module Searchlogic
         # * <tt>Default:</tt> "# The class name for used in the page_link helper
         #
         # * <tt>Default:</tt> "page"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def order_by_links_ordering_by_class_name
-          @order_by_links_ordering_by_class_name ||= "ordering_by"
+          return @order_by_links_ordering_by_class_name if defined?(@order_by_links_ordering_by_class_name)
+          @order_by_links_ordering_by_class_name = "ordering_by"
         end
         attr_writer :order_by_links_ordering_by_class_name
         
@@ -95,12 +99,27 @@ module Searchlogic
         end
         attr_writer :order_by_select_class_name
         
+        # Makes page_links look just like the output of will_paginate.
+        #
+        # * <tt>Default:</tt> false
+        # * <tt>Accepts:</tt> Boolean
+        def page_links_act_like_will_paginate
+          @page_links_act_like_will_paginate ||= false
+        end
+        attr_writer :page_links_act_like_will_paginate
+        
+        # Convenience methods for determining if page_links_act_like_will_paginate is set to true
+        def page_links_act_like_will_paginate?
+          page_links_act_like_will_paginate == true
+        end
+        
         # The class name for used in the page_link helper
         #
         # * <tt>Default:</tt> "page"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def page_link_class_name
-          @page_link_class_name ||= "page"
+          return @page_link_class_name if defined?(@page_link_class_name)
+          @page_link_class_name = "page"
         end
         attr_writer :page_link_class_name
         
@@ -115,7 +134,8 @@ module Searchlogic
         # * <tt>Default:</tt> "current_page"
         # * <tt>Accepts:</tt> String, set to nil to disable
         def page_links_current_page_class_name
-          @page_links_current_page_class_name ||= "current_page"
+          return @page_links_current_page_class_name if defined?(@page_links_current_page_class_name)
+          @page_links_current_page_class_name = page_links_act_like_will_paginate? ? "current" : "current_page"
         end
         attr_writer :page_links_current_page_class_name
         
@@ -124,10 +144,31 @@ module Searchlogic
         # * <tt>Default:</tt> "disabled_page"
         # * <tt>Accepts:</tt> String, set to nil to disable
         def page_links_disabled_class_name
-          @page_links_disabled_class_name ||= "disabled_page"
+          return @page_links_disabled_class_name if defined?(@page_links_disabled_class_name)
+          @page_links_disabled_class_name = page_links_act_like_will_paginate? ? "disabled" : "disabled_page"
         end
         attr_writer :page_links_disabled_class_name
         
+        # Wraps page links in a div
+        #
+        # * <tt>Default:</tt> false
+        # * <tt>Accepts:</tt> Boolean
+        def page_links_div_wrapper
+          return @page_links_div_wrapper if defined?(@page_links_div_wrapper)
+          @page_links_div_wrapper = page_links_act_like_will_paginate?
+        end
+        attr_writer :page_links_div_wrapper
+        
+        # If page_links_div_wrapper is true you can specify a class name here.
+        #
+        # * <tt>Default:</tt> "pagination"
+        # * <tt>Accepts:</tt> String, set to nil to disable
+        def page_links_div_wrapper_class_name
+          return @page_links_div_wrapper_class_name if defined?(@page_links_div_wrapper_class_name)
+          @page_links_div_wrapper_class_name = "pagination"
+        end
+        attr_writer :page_links_div_wrapper_class_name
+        
         # The default for the :first option for the page_links helper.
         #
         # * <tt>Default:</tt> nil
@@ -149,9 +190,10 @@ module Searchlogic
         # The class for the first page link
         #
         # * <tt>Default:</tt> "first_page"
-        # * <tt>Accepts:</tt> String, nil to disable
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def page_links_first_page_class_name
-          @page_links_first_page_class_name ||= "first_page"
+          return @page_links_first_page_class_name if defined?(@page_links_first_page_class_name)
+          @page_links_first_page_class_name = "first_page"
         end
         attr_writer :page_links_first_page_class_name
         
@@ -167,9 +209,10 @@ module Searchlogic
         # The class for the last page link
         #
         # * <tt>Default:</tt> "last_page"
-        # * <tt>Accepts:</tt> String, nil to disable
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def page_links_last_page_class_name
-          @page_links_last_page_class_name ||= "last_page"
+          return @page_links_last_page_class_name if defined?(@page_links_last_page_class_name)
+          @page_links_last_page_class_name = "last_page"
         end
         attr_writer :page_links_last_page_class_name
         
@@ -185,9 +228,10 @@ module Searchlogic
         # The class for the next page link
         #
         # * <tt>Default:</tt> "next_page"
-        # * <tt>Accepts:</tt> String, nil to disable
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def page_links_next_page_class_name
-          @page_links_next_page_class_name ||= "next_page"
+          return @page_links_next_page_class_name if defined?(@page_links_next_page_class_name)
+          @page_links_next_page_class_name = "next_page"
         end
         attr_writer :page_links_next_page_class_name
         
@@ -203,9 +247,10 @@ module Searchlogic
         # The class for the previous page link
         #
         # * <tt>Default:</tt> "prev_page"
-        # * <tt>Accepts:</tt> String, nil to disable
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def page_links_prev_page_class_name
-          @page_links_prev_page_class_name ||= "prev_page"
+          return @page_links_prev_page_class_name if defined?(@page_links_prev_page_class_name)
+          @page_links_prev_page_class_name = "prev_page"
         end
         attr_writer :page_links_prev_page_class_name
         
@@ -221,18 +266,20 @@ module Searchlogic
         # The class name for used in the page_seect helper
         #
         # * <tt>Default:</tt> "page"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def page_select_class_name
-          @page_select_class_name ||= "page"
+          return @page_select_class_name if defined?(@page_select_class_name)
+          @page_select_class_name = "page"
         end
         attr_writer :page_select_class_name
         
         # The class name for used in the per_page_link helper
         #
         # * <tt>Default:</tt> "per_page"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def per_page_link_class_name
-          @per_page_link_class_name ||= "per_page"
+          return @per_page_link_class_name if defined?(@per_page_link_class_name)
+          @per_page_link_class_name = "per_page"
         end
         attr_writer :per_page_link_class_name
         
@@ -251,9 +298,10 @@ module Searchlogic
         # The class name for used in the per_page_select helper
         #
         # * <tt>Default:</tt> "per_page"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def per_page_select_class_name
-          @per_page_select_class_name ||= "per_page"
+          return @per_page_select_class_name if defined?(@per_page_select_class_name)
+          @per_page_select_class_name = "per_page"
         end
         attr_writer :per_page_select_class_name
         
@@ -269,9 +317,10 @@ module Searchlogic
         # The class name for used in the priority_order_by_link helper
         #
         # * <tt>Default:</tt> "priority_order_by"
-        # * <tt>Accepts:</tt> String
+        # * <tt>Accepts:</tt> String, set to nil to disable
         def priority_order_by_link_class_name
-          @priority_order_by_link_class_name ||= "priority_order_by"
+          return @priority_order_by_link_class_name if defined?(@priority_order_by_link_class_name)
+          @priority_order_by_link_class_name = "priority_order_by"
         end
         attr_writer :priority_order_by_link_class_name
       

data/lib/searchlogic/helpers/control_types/links.rb

@@ -159,6 +159,7 @@ module Searchlogic
           
           html += span_or_page_link(:next, options.deep_dup, options[:current_page] == options[:last_page]) if options[:next]
           html += span_or_page_link(:last, options.deep_dup, options[:current_page] == options[:last_page]) if options[:last]
+          html = content_tag(:div, html, :class => Config.helpers.page_links_div_wrapper_class_name) if Config.helpers.page_links_div_wrapper
           html
         end
         

data/lib/searchlogic/helpers/form.rb

@@ -70,7 +70,7 @@ module Searchlogic
             when String, Symbol
               args.unshift(search_object).unshift(first)
             else
-              name = search_object.is_a?(Conditions::Base) ? (search_object.relationship_name || :conditions) : :search
+              name = search_object.is_a?(Conditions::Base) ? (search_object.object_name || :conditions) : :search
               args.unshift(search_object).unshift(name)
             end
             

data/lib/searchlogic/shared/utilities.rb

@@ -7,6 +7,7 @@ module Searchlogic
           conditions.delete_if { |condition| condition.blank? }
           return if conditions.blank?
           return conditions.first if conditions.size == 1
+          options[:scope] = true unless options.key?(:scope)
         
           conditions_strs = []
           conditions_subs = []
@@ -20,14 +21,20 @@ module Searchlogic
         
           return if conditions_strs.blank?
         
-          join = options[:any] ? "OR" : "AND"
-          conditions_str = "(#{conditions_strs.join(") #{join} (")})"
+          join = options[:any] ? " OR " : " AND "
+          conditions_str = options[:scope] ? "(#{conditions_strs.join(")#{join}(")})" : conditions_strs.join(join)
         
           return conditions_str if conditions_subs.blank?
         
           [conditions_str, *conditions_subs]
         end
         
+        def scope_condition(condition)
+          arr_condition = condition.is_a?(Array) ? condition : [condition]
+          arr_condition[0] = "(#{arr_condition[0]})"
+          arr_condition.size == 1 ? arr_condition.first : arr_condition
+        end
+        
         def merge_joins(*joins)
           joins.delete_if { |join| join.blank? }
           return if joins.blank?

data/lib/searchlogic/version.rb

@@ -67,7 +67,7 @@ module Searchlogic
 
     MAJOR = 1
     MINOR = 5
-    TINY  = 4
+    TINY  = 6
 
     # The current version as a Version instance
     CURRENT = new(MAJOR, MINOR, TINY)

data/lib/searchlogic.rb

@@ -38,6 +38,9 @@ require "searchlogic/search/base"
 require "searchlogic/search/protection"
 
 # Conditions
+require "searchlogic/conditions/any_or_all"
+require "searchlogic/conditions/groups"
+require "searchlogic/conditions/magic_methods"
 require "searchlogic/conditions/protection"
 require "searchlogic/conditions/base"
 
@@ -76,6 +79,9 @@ module Searchlogic
   
   module Conditions
     class Base
+      include AnyOrAll
+      include Groups
+      include MagicMethods
       include Protection
     end