searchgasm 0.9.6 → 0.9.7

data/lib/searchgasm/conditions/base.rb

@@ -0,0 +1,221 @@
+module Searchgasm
+  module Conditions # :nodoc:
+    # = Conditions
+    #
+    # Represents a collection of conditions and performs various tasks on that collection. For information on each condition see Searchgasm::Condition.
+    # Each condition has its own file and class and the source for each condition is pretty self explanatory.
+    class Base
+      include Utilities
+      
+      attr_accessor :klass, :relationship_name, :scope
+      
+      class << self
+        # Registers a condition as an available condition for a column or a class.
+        #
+        # === Example
+        #
+        #   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". 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
+        #     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()
+        #     def to_conditions(value)
+        #       ["#{quoted_table_name}.#{quoted_column_name} SOUNDS LIKE ?", value]
+        #     end
+        #   end
+        #
+        #   Searchgasm::Seearch::Conditions.register_condition(SoundsLikeCondition)
+        def register_condition(klass)
+          raise(ArgumentError, "You can only register conditions that extend Searchgasm::Condition::Base") unless klass.ancestors.include?(Searchgasm::Condition::Base)
+          conditions << klass unless conditions.include?(klass)
+        end
+        
+        # A list of available condition type classes
+        def conditions
+          @@conditions ||= []
+        end
+        
+        def needed?(klass, conditions) # :nodoc:
+          if conditions.is_a?(Hash)
+            conditions.stringify_keys.keys.each do |condition|
+              return true unless klass.column_names.include?(condition)
+            end
+          end
+          
+          false
+        end
+      end
+      
+      def initialize(klass, init_conditions = {})
+        self.klass = klass
+        add_klass_conditions!
+        add_column_conditions!
+        add_associations!
+        self.conditions = init_conditions
+      end
+      
+      # Setup methods for searching
+      [:all, :average, :calculate, :count, :find, :first, :maximum, :minimum, :sum].each do |method|
+        class_eval <<-"end_eval", __FILE__, __LINE__
+          def #{method}(*args)
+            self.conditions = args.extract_options!
+            args << {:conditions => sanitize}
+            klass.#{method}(*args)
+          end
+        end_eval
+      end
+      
+      # A list of includes to use when searching, includes relationships
+      def includes
+        i = []
+        associations.each do |association|
+          association_includes = association.includes
+          i << (association_includes.blank? ? association.relationship_name.to_sym : {association.relationship_name.to_sym => association_includes})
+        end
+        i.blank? ? nil : (i.size == 1 ? i.first : i)
+      end
+      
+      # Sanitizes the conditions down into conditions that ActiveRecord::Base.find can understand.
+      def sanitize
+        conditions = merge_conditions(*objects.collect { |object| object.sanitize })
+        return scope if conditions.blank?
+        merge_conditions(conditions, scope)
+      end
+      
+      # Allows you to set the conditions via a hash. If you do not pass a hash it will set scope instead, so that you can continue to add conditions and ultimately
+      # merge it all together at the end.
+      def conditions=(conditions)
+        case conditions
+        when Hash
+          assert_valid_conditions(conditions)
+          remove_conditions_from_protected_assignement(conditions).each { |condition, value| send("#{condition}=", value) }
+        else
+          self.scope = conditions
+        end
+      end
+      
+      # All of the active conditions (conditions that have been set)
+      def conditions
+        conditions_hash = {}
+        objects.each do |object|
+          case object
+          when self.class
+            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
+          end
+        end
+        conditions_hash
+      end
+      
+      private
+        def add_associations!
+          klass.reflect_on_all_associations.each do |association|
+            self.class.class_eval <<-"end_eval", __FILE__, __LINE__
+              def #{association.name}
+                if @#{association.name}.nil?
+                  @#{association.name} = self.class.new(#{association.class_name})
+                  @#{association.name}.relationship_name = "#{association.name}"
+                  objects << @#{association.name}
+                end
+                @#{association.name}
+              end
+            
+              def #{association.name}=(conditions); #{association.name}.conditions = conditions; end
+              def reset_#{association.name}!; objects.delete(#{association.name}); @#{association.name} = nil; end
+            end_eval
+          end
+        end
+        
+        def add_column_conditions!
+          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) }
+            end
+          end
+        end
+        
+        def add_condition!(condition, name, column = nil)
+          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}
+              end
+              @#{name}
+            end
+
+            def #{name}; #{name}_object.value; end
+            def #{name}=(value); #{name}_object.value = value; end
+            def reset_#{name}!; objects.delete(#{name}_object); @#{name} = nil; end
+          end_eval
+        end
+        
+        def add_condition_alias!(alias_name, name)
+          condition_names << alias_name
+          self.class.class_eval do
+            alias_method alias_name, name
+            alias_method "#{alias_name}=", "#{name}="
+          end
+        end
+        
+        def add_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
+        end
+        
+        def assert_valid_conditions(conditions)
+          keys = condition_names.collect { |condition_name| condition_name.to_sym }
+          keys += klass.reflect_on_all_associations.collect { |association| association.name }
+          conditions.symbolize_keys.assert_valid_keys(keys)
+        end
+        
+        def associations
+          objects.select { |object| object.is_a?(self.class) }
+        end
+        
+        def condition_names
+          @condition_names ||= []
+        end
+        
+        def objects
+          @objects ||= []
+        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/searchgasm/conditions/protection.rb

@@ -0,0 +1,30 @@
+module Searchgasm
+  module Conditions
+    # = Conditions Protection
+    #
+    # Adds protection from SQL injections. Just set protect = true and it will limit what kind of conditions it will accept.
+    module Protection
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :protect
+          alias_method_chain :conditions=, :protection
+        end
+      end
+      
+      def conditions_with_protection=(conditions)
+        unless conditions.is_a?(Hash)
+          if protect?
+            return if conditions.blank?
+            raise(ArgumentError, "You can not set a scope or pass SQL while the search is being protected")
+          end
+        end
+        
+        self.conditions_without_protection = conditions
+      end
+      
+      def protect?
+        protect == true
+      end
+    end
+  end
+end

data/lib/searchgasm/config.rb

@@ -0,0 +1,137 @@
+module Searchgasm
+  # = Config
+  # Adds default configuration for all of searchgasm. Just make sure you set your config before you use Searchgasm.
+  # For rails the best place to do this is in config/initializers. Create a file in there called searchgasm.rb with the following content:
+  #
+  # === Example
+  #
+  #   # config/iniitializers/searchgasm.rb
+  #   Searchgasm::Config.configure do |config|
+  #     config.you_option_here = your_value # see methods below
+  #   end
+  class Config
+    class << self
+      # Convenience method for setting configuration
+      # See example at top of class.
+      def configure
+        yield self
+      end
+      
+      def asc_indicator # :nodoc:
+        @asc_indicator ||= "&nbsp;&#9650;"
+      end
+      
+      # The indicator that is used when the sort of a column is ascending
+      #
+      # * <tt>Default:</tt> &nbsp;&#9650;
+      # * <tt>Accepts:</tt> String or a Proc.
+      #
+      # === Examples
+      #
+      #   config.asc_indicator = "(ASC)"
+      #   config.asc_indicator = Proc.new { |template| template.image_tag("asc.jpg") }
+      def asc_indicator=(value)
+        @asc_indicator = value
+      end
+      
+      def desc_indicator # :nodoc:
+        @desc_indicator ||= "&nbsp;&#9660;"
+      end
+      
+      # See asc_indicator=
+      def desc_indicator=(value)
+        @desc_indicator = value
+      end
+      
+      def pages_type # :nodoc:
+        @pages_type ||= :select
+      end
+      
+      # The default value for the :type option in the pages helper.
+      #
+      # * <tt>Default:</tt> :select
+      # * <tt>Accepts:</tt> :select, :links
+      def pages_type=(value)
+        @pages_type = value.to_sym
+      end
+      
+      def per_page_choices # :nodoc:
+        @per_page_choices ||= [10, 25, 50, 100, 150, 200, nil]
+      end
+      
+      # The choices used in the per_page helper
+      #
+      # * <tt>Default:</tt> [10, 25, 50, 100, 150, 200, nil]
+      # * <tt>Accepts:</tt> Array
+      #
+      # nil means "Show all"
+      def per_page_choices=(value)
+        @per_page_choices = value
+      end
+      
+      def per_page_type # :nodoc:
+        @per_page_type ||= :select
+      end
+      
+      # The default value for the :type option in the per_page helper.
+      #
+      # * <tt>Default:</tt> :select
+      # * <tt>Accepts:</tt> :select, :links
+      def per_page_type=(value)
+        @per_page_type = value.to_sym
+      end
+      
+      def hidden_fields # :nodoc:
+        @hidden_fields ||= (Search::Base::SPECIAL_FIND_OPTIONS - [:page])
+      end
+      
+      # Which hidden fields to automatically include when creating a form with a Searchgasm object. See Searchgasm::Helpers::FormHelper for more info.
+      #
+      # * <tt>Default:</tt> [:order_by, :order_as, :per_page]
+      # * <tt>Accepts:</tt> Array, nil, false
+      def hidden_fields=(value)
+        @hidden_fields = value
+      end
+      
+      def remote_helpers # :nodoc:
+        @remote_helpers ||= false
+      end
+      
+      # Tells all helpers to default to using remote links (AJAX) instead of normal links.
+      #
+      # * <tt>Default:</tt> false
+      # * <tt>Accepts:</tt> Boolean
+      #
+      # nil means "Show all"
+      def remote_helpers=(value)
+        @remote_helpers = value
+      end
+      
+      def remote_helpers? # :nodoc:
+        remote_helpers == true
+      end
+      
+      def search_scope # :nodoc:
+        
+      end
+      
+      def search_obj_name # :nodoc:
+        @search_obj_name ||= :@search
+      end
+      
+      # The instance variable name you use to assign your search to. This allows the helpers to grab your Searchgasm object without having
+      # to specify it everywhere.
+      #
+      # * <tt>Default:</tt> :@search
+      # * <tt>Accepts:</tt> String or Symbol.
+      #
+      # === Examples
+      #
+      #   config.search_obj_name = :@search
+      #   config.search_obj_name = "@search"
+      def search_obj_name=(value)
+        @search_obj_name = value
+      end
+    end
+  end
+end

data/lib/searchgasm/helpers/form_helper.rb

@@ -0,0 +1,159 @@
+module Searchgasm
+  module Helpers
+    # = Form Helper
+    #
+    # Enables you to use form_for and fields_for just like you do with an ActiveRecord object.
+    #
+    # === Examples
+    #
+    # Let's assume @search is searching Address
+    #
+    #   form_for(@search) # is equivalent to form_for(:search, @search, :url => addresses_path)
+    #   form_for([@current_user, @search]) # is equivalent to form_for(:search, @search, :url => user_addresses_path(@current_user))
+    #   form_for([:admin, @search]) # is equivalent to form_for(:search, @search, :url => admin_addresses_path)
+    #   form_for(:search, @search, :url => whatever_path)
+    #
+    # The goal was to mimic ActiveRecord. You can also pass a Searchgasm::Conditions::Base object as well and it will function the same way.
+    #
+    # === Automatic hidden fields generation
+    #
+    # If you pass a Searchgasm::Search::Base object it automatically adds the :order_by, :order_as, and :per_page hidden fields. This is done so that when someone
+    # creates a new search, their options are remembered. It keeps the search consisten and is much more user friendly. If you want to override this you can pass the
+    # following options. Or you can set this up in your configuration, see Searchgasm::Config for more details.
+    #
+    # === Options
+    #
+    # * <tt>:hidden_fields</tt> --- Array, a list of hidden fields to include. Defaults to [:order_by, :order_as, :per_page]. Pass false, nil, or a blank array to not include any.
+    module FormHelper
+      module Shared # :nodoc:
+        private
+          def searchgasm_object?(object)
+            object.is_a?(Search::Base) || object.is_a?(Conditions::Base)
+          end
+        
+          def find_searchgasm_object(args)
+            case args.first
+            when String, Symbol
+              search_object = searchgasm_object?(args[1]) ? args[1] : instance_variable_get("@#{args.first}")
+            when Array
+              search_object = args.first.last
+            else
+              search_object = args.first
+            end
+          
+            searchgasm_object?(search_object) ? search_object : nil
+          end
+        
+          def searchgasm_args(args, search_object, for_helper = nil)
+            args = args.dup
+            first = args.shift
+          
+            # Setup args
+            case first
+            when String, Symbol
+              args.unshift(search_object).unshift(first)
+            else
+              name = search_object.is_a?(Conditions::Base) ? (search_object.relationship_name || :conditions) : :search
+              args.unshift(search_object).unshift(name)
+            end
+          
+            if for_helper != :fields_for
+              options = args.extract_options!
+              options[:html] ||= {}
+              options[:html][:method] ||= :get
+              options[:method] ||= options[:html][:method] if for_helper == :remote_form_for
+              options[:html][:id] ||= searchgasm_form_id(search_object)
+          
+              # Setup options
+              case first
+              when Array
+                first.pop
+                first << search_object.klass.new
+                options[:url] ||= polymorphic_path(first)
+              else
+                options[:url] ||= polymorphic_path(search_object.klass.new)
+              end
+          
+              args << options
+            end
+          
+            args
+          end
+        
+          def insert_searchgasm_fields(args, search_object)
+            return unless search_object.is_a?(Search::Base)
+            name = args.first
+            options = args.extract_options!
+            (options.delete(:hidden_fields) || Config.hidden_fields).each do |option|
+              concat(hidden_field(name, option, :object => search_object, :value => (option == :order_by ? searchgasm_order_by_value(search_object.order_by) : search_object.send(option))))
+            end
+            args << options
+          end
+      end
+      
+      module Base # :nodoc:
+        include Shared
+
+        def fields_for_with_searchgasm(*args, &block)
+          search_object = find_searchgasm_object(args)
+          if search_object
+            new_args = searchgasm_args(args, search_object, :fields_for)
+            insert_searchgasm_fields(new_args, search_object)
+            fields_for_without_searchgasm(*new_args, &block)
+          else
+            fields_for_without_searchgasm(*args, &block)
+          end
+        end
+      
+        def form_for_with_searchgasm(*args, &block)
+          search_object = find_searchgasm_object(args)
+          if search_object
+            form_for_without_searchgasm(*searchgasm_args(args, search_object, :form_for), &block)
+          else
+            form_for_without_searchgasm(*args, &block)
+          end
+        end
+      
+        def remote_form_for_with_searchgasm(*args, &block)
+          search_object = find_searchgasm_object(args)
+          if search_object
+            remote_form_for_without_searchgasm(*searchgasm_args(args, search_object, :remote_form_for), &block)
+          else
+            remote_form_for_without_searchgasm(*args, &block)
+          end
+        end
+      end
+    
+      module FormBuilder # :nodoc:
+        include Shared
+        
+        def fields_for_with_searchgasm(*args, &block)
+          search_object = find_searchgasm_object(args)
+          if search_object
+            new_args = searchgasm_args(args, search_object, :fields_for)
+            insert_searchgasm_fields(new_args, search_object)
+            fields_for_without_searchgasm(*new_args, &block)
+          else
+            fields_for_without_searchgasm(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActionView)
+  ActionView::Base.send(:include, Searchgasm::Helpers::FormHelper::Base)
+
+  ActionView::Base.class_eval do
+    alias_method_chain :fields_for, :searchgasm
+    alias_method_chain :form_for, :searchgasm
+    alias_method_chain :remote_form_for, :searchgasm
+  end
+
+  ActionView::Helpers::FormBuilder.send(:include, Searchgasm::Helpers::FormHelper::FormBuilder)
+
+  ActionView::Helpers::FormBuilder.class_eval do
+    alias_method_chain :fields_for, :searchgasm
+  end
+end