searchlogic 1.5.3

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'echoe'
+
+require File.dirname(__FILE__) << "/lib/searchlogic/version"
+
+Echoe.new 'searchlogic' do |p|
+  p.version = Searchlogic::Version::STRING
+  p.author = "Ben Johnson of Binary Logic"
+  p.email  = 'bjohnson@binarylogic.com'
+  p.project = 'searchlogic'
+  p.summary = "Object based ActiveRecord searching, ordering, pagination, and more!"
+  p.url = "http://github.com/binarylogic/searchlogic"
+  p.dependencies = %w(activerecord activesupport)
+  p.include_rakefile = true
+end

data/TODO.rdoc

@@ -0,0 +1,6 @@
+= To Do
+
+1. Perform "more efficient" checks: year_of_created_at = 2008 and month_of_created_at = 8. Should result in a "BETWEEN" statement utilizing the column indexes. Thanks Georg for letting me know about this.
+2. Solve conflicts between scope joins and joins in the search (for old versions of AR). Also solve conflicts between joins and includes.
+3. Add configuration to change the "english" words
+4. Re-add the distinct option

data/examples/README.rdoc

@@ -0,0 +1,4 @@
+=== Live example
+
+*	Please see the live example: http://searchlogic_example.binarylogic.com
+*	Source / Github project for the example: http://github.com/binarylogic/searchlogic_example.binarylogic.com

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) << "/lib/searchlogic"

data/lib/searchlogic.rb

@@ -0,0 +1,89 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "active_support"
+require "active_record"
+require "active_record/version"
+
+["mysql", "postgresql", "sqlite"].each do |adapter_name|
+  begin
+    require "active_record/connection_adapters/#{adapter_name}_adapter"
+    require "searchlogic/active_record/connection_adapters/#{adapter_name}_adapter"
+  rescue Exception
+  end
+end
+
+# Core Ext
+require "searchlogic/core_ext/hash"
+
+# Shared
+require "searchlogic/shared/utilities"
+require "searchlogic/shared/virtual_classes"
+
+# Base classes
+require "searchlogic/version"
+require "searchlogic/config/helpers"
+require "searchlogic/config/search"
+require "searchlogic/config"
+
+# ActiveRecord
+require "searchlogic/active_record/base"
+require "searchlogic/active_record/associations"
+
+# Search
+require "searchlogic/search/ordering"
+require "searchlogic/search/pagination"
+require "searchlogic/search/conditions"
+require "searchlogic/search/searching"
+require "searchlogic/search/base"
+require "searchlogic/search/protection"
+
+# Conditions
+require "searchlogic/conditions/protection"
+require "searchlogic/conditions/base"
+
+# Condition
+require "searchlogic/condition/base"
+require "searchlogic/condition/tree"
+SEARCHGASM_CONDITIONS = [:begins_with, :blank, :child_of, :descendant_of, :ends_with, :equals, :greater_than, :greater_than_or_equal_to, :inclusive_descendant_of, :like, :nil, :not_begin_with, :not_blank, :not_end_with, :not_equal, :not_have_keywords, :not_nil, :keywords, :less_than, :less_than_or_equal_to, :sibling_of]
+SEARCHGASM_CONDITIONS.each { |condition| require "searchlogic/condition/#{condition}" }
+
+# Modifiers
+require "searchlogic/modifiers/base"
+SEARCHGASM_MODIFIERS = [:absolute, :acos, :asin, :atan, :ceil, :char_length, :cos, :cot, :day_of_month, :day_of_week, :day_of_year, :degrees, :exp, :floor, :hex, :hour, :log, :log10, :log2, :lower, :ltrim, :md5, :microseconds, :milliseconds, :minute, :month, :octal, :radians, :round, :rtrim, :second, :sign, :sin, :square_root, :tan, :trim, :upper, :week, :year]
+SEARCHGASM_MODIFIERS.each { |modifier| require "searchlogic/modifiers/#{modifier}" }
+
+# Helpers
+require "searchlogic/helpers/utilities"
+require "searchlogic/helpers/form"
+require "searchlogic/helpers/control_types/link"
+require "searchlogic/helpers/control_types/links"
+require "searchlogic/helpers/control_types/select"
+require "searchlogic/helpers/control_types/remote_link"
+require "searchlogic/helpers/control_types/remote_links"
+require "searchlogic/helpers/control_types/remote_select"
+
+# Lets do it!
+module Searchlogic
+  module Search
+    class Base
+      include Conditions
+      include Ordering
+      include Protection
+      include Pagination
+      include Searching
+    end
+  end
+  
+  module Conditions
+    class Base
+      include Protection
+    end
+    
+    SEARCHGASM_CONDITIONS.each { |condition| Base.register_condition("Searchlogic::Condition::#{condition.to_s.camelize}".constantize) }
+    SEARCHGASM_MODIFIERS.each { |modifier| Base.register_modifier("Searchlogic::Modifiers::#{modifier.to_s.camelize}".constantize) }
+  end
+  
+  # The namespace I put all cached search classes.
+  module Cache
+  end
+end

data/lib/searchlogic/active_record/associations.rb

@@ -0,0 +1,52 @@
+module Searchlogic
+  module ActiveRecord
+    # = Searchlogic ActiveRecord Associations
+    #
+    # These methods hook into ActiveRecords association methods and add in searchlogic functionality.
+    module Associations
+      module AssociationCollection
+        # This needs to be implemented because AR doesn't leverage scopes with this method like it probably should
+        def find_with_searchlogic(*args)
+          options = args.extract_options!
+          args << filter_options_with_searchlogic(options)
+          find_without_searchlogic(*args)
+        end
+      end
+      
+      module HasManyAssociation
+        def count_with_searchlogic(*args)
+          options = args.extract_options!
+          args << filter_options_with_searchlogic(options)
+          count_without_searchlogic(*args)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Associations::AssociationCollection.class_eval do
+  if respond_to?(:find)
+    include Searchlogic::ActiveRecord::Associations::AssociationCollection
+    alias_method_chain :find, :searchlogic
+  end
+end
+
+ActiveRecord::Associations::HasManyAssociation.class_eval do
+  include Searchlogic::ActiveRecord::Associations::HasManyAssociation
+  alias_method_chain :count, :searchlogic
+  
+  # Older versions of AR have find in here, not in AssociationCollection
+  include Searchlogic::ActiveRecord::Associations::AssociationCollection
+  alias_method_chain :find, :searchlogic
+end
+
+ActiveRecord::Associations::ClassMethods::InnerJoinDependency::InnerJoinAssociation.class_eval do
+  private
+    # Inner joins impose limitations on queries. They can be quicker but you can't do OR conditions when conditions
+    # overlap from the base model to any of its associations. Also, inner joins won't allow you to order by an association
+    # attribute. What if the association is optional? All of those records are ommitted. It just doesn't make sense to default
+    # to inner joins when providing this as a "convenience" when searching. So let's change it.
+    def join_type
+      "LEFT OUTER JOIN"
+    end
+end

data/lib/searchlogic/active_record/base.rb

@@ -0,0 +1,218 @@
+module Searchlogic
+  # == Searchlogic ActiveRecord
+  #
+  # Hooks into ActiveRecord to add all of the searchlogic functionality into your models. Only uses what is publically available, doesn't dig into internals, and
+  # searchlogic only gets involved when needed.
+  module ActiveRecord
+    # = Searchlogic ActiveRecord Base
+    # Adds in base level functionality to ActiveRecord
+    module Base
+      # This is an alias method chain. It hook into ActiveRecord's "calculate" method and checks to see if Searchlogic should get involved.
+      def calculate_with_searchlogic(*args)
+        options = args.extract_options!
+        options = filter_options_with_searchlogic(options, false)
+        args << options
+        calculate_without_searchlogic(*args)
+      end
+      
+      # This is an alias method chain. It hooks into ActiveRecord's "find" method and checks to see if Searchlogic should get involved.
+      def find_with_searchlogic(*args)
+        options = args.extract_options!
+        options = filter_options_with_searchlogic(options)
+        args << options
+        find_without_searchlogic(*args)
+      end
+      
+      # This is an alias method chain. It hooks into ActiveRecord's scopes and checks to see if Searchlogic should get involved. Allowing you to use all of Searchlogics conditions and tools
+      # in scopes as well.
+      #
+      # === Examples
+      #
+      # Named scopes:
+      #
+      #   named_scope :top_expensive, :conditions => {:total_gt => 1_000_000}, :per_page => 10
+      #   named_scope :top_expensive_ordered, :conditions => {:total_gt => 1_000_000}, :per_page => 10, :order_by => {:user => :first_name}
+      #
+      # Good ole' regular scopes:
+      #
+      #   with_scope(:find => {:conditions => {:total_gt => 1_000_000}, :per_page => 10}) do
+      #     find(:all)
+      #   end
+      #
+      #   with_scope(:find => {:conditions => {:total_gt => 1_000_000}, :per_page => 10}) do
+      #     build_search
+      #   end
+      def with_scope_with_searchlogic(method_scoping = {}, action = :merge, &block)
+        method_scoping[:find] = filter_options_with_searchlogic(method_scoping[:find]) if method_scoping[:find]
+        with_scope_without_searchlogic(method_scoping, action, &block)
+      end
+      
+      # This is a special method that Searchlogic adds in. It returns a new search object on the model. So you can search via an object.
+      #
+      # <b>This method is "protected". Meaning it checks the passed options for SQL injections. So trying to write raw SQL in *any* of the option will result in a raised exception. It's safe to pass a params object when instantiating.</b>
+      #
+      # This method has an alias "new_search"
+      #
+      # === Examples
+      #
+      #   search = User.new_search
+      #   search.conditions.first_name_contains = "Ben"
+      #   search.per_page = 20
+      #   search.page = 2
+      #   search.order_by = {:user_group => :name}
+      #   search.all # can call any search method: first, find(:all), find(:first), sum("id"), etc...
+      def build_search(options = {}, &block)
+        search = searchlogic_search
+        search.protect = true
+        search.options = options
+        yield search if block_given?
+        search
+      end
+      
+      # See build_search. This is the same method but *without* protection. Do *NOT* pass in a params object to this method.
+      #
+      # This also has an alias "new_search!"
+      def build_search!(options = {}, &block)
+        search = searchlogic_search(options)
+        yield search if block_given?
+        search
+      end
+      
+      # Similar to ActiveRecord's attr_protected, but for conditions. It will block any conditions in this array that are being mass assigned. Mass assignments are:
+      #
+      # === Examples
+      #
+      # search = User.new_search(:conditions => {:first_name_like => "Ben", :email_contains => "binarylogic.com"})
+      # search.options = {:conditions => {:first_name_like => "Ben", :email_contains => "binarylogic.com"}}
+      #
+      # If first_name_like is in the list of conditions_protected then it will be removed from the hash.
+      def conditions_protected(*conditions)
+        write_inheritable_attribute(:conditions_protected, Set.new(conditions.map(&:to_s)) + (protected_conditions || []))
+      end
+
+      def protected_conditions # :nodoc:
+        read_inheritable_attribute(:conditions_protected)
+      end
+      
+      # This is the reverse of conditions_protected. You can specify conditions here and *only* these conditions will be allowed in mass assignment. Any condition not specified here will be blocked.
+      def conditions_accessible(*conditions)
+        write_inheritable_attribute(:conditions_accessible, Set.new(conditions.map(&:to_s)) + (accessible_conditions || []))
+      end
+
+      def accessible_conditions # :nodoc:
+        read_inheritable_attribute(:conditions_accessible)
+      end
+    
+      private
+        def filter_options_with_searchlogic(options = {}, searching = true)
+          return options unless Searchlogic::Search::Base.needed?(self, options)
+          search = Searchlogic::Search::Base.create_virtual_class(self).new # call explicitly to avoid merging the scopes into the search
+          search.acting_as_filter = true
+          search.scope = scope(:find)
+          conditions = options.delete(:conditions) || options.delete("conditions") || {}
+          if conditions
+            case conditions
+            when Hash
+              conditions.each { |condition, value| search.conditions.send("#{condition}=", value) } # explicitly call to enforce blanks
+            else
+              search.conditions = conditions
+            end
+          end
+          search.options = options
+          search.sanitize(searching)
+        end
+        
+        def searchlogic_search(options = {})
+          scope = {}
+          current_scope = scope(:find) && scope(:find).deep_dup
+          if current_scope
+            [:conditions, :include, :joins].each do |option|
+              value = current_scope.delete(option)
+              next if value.blank?
+              scope[option] = value
+            end
+            
+            # Delete nil values in the scope, for some reason habtm relationships like to pass :limit => nil
+            new_scope = {}
+            current_scope.each { |k, v| new_scope[k] = v unless v.nil? }
+            current_scope = new_scope
+          end
+          search = Searchlogic::Search::Base.create_virtual_class(self).new
+          search.scope = scope
+          search.options = current_scope
+          search.options = options
+          search
+        end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, Searchlogic::ActiveRecord::Base)
+
+module ActiveRecord #:nodoc: all
+  class Base
+    class << self
+      alias_method_chain :calculate, :searchlogic
+      alias_method_chain :find, :searchlogic
+      alias_method_chain :with_scope, :searchlogic
+      alias_method :new_search, :build_search
+      alias_method :new_search!, :build_search!
+      
+      def valid_find_options
+        VALID_FIND_OPTIONS
+      end
+      
+      def valid_calculations_options
+        Calculations::CALCULATIONS_OPTIONS
+      end
+      
+      private
+        # This is copied over from 2 different versions of ActiveRecord. I have to do this in order to preserve the "auto joins"
+        # as symbols. Keeping them as symbols allows ActiveRecord to merge them properly. The problem is when they conflict with includes.
+        # Includes add joins also, and they add them before joins do. So if they already added them skip them. Now you can do queries like:
+        #
+        # User.all(:joins => {:orders => :line_items}, :include => :orders)
+        #
+        # Where as before, the only way to get the above query to work would be to include line_items also, which is not neccessarily what you want.
+        def add_joins!(sql, options_or_joins, scope = :auto) # :nodoc:
+          code_type = (respond_to?(:array_of_strings?, true) && :array_of_strings) || (respond_to?(:merge_joins, true) && :merge_joins)
+
+          case code_type
+          when :array_of_strings, :merge_joins
+            joins = options_or_joins
+            scope = scope(:find) if :auto == scope
+            merged_joins = scope && scope[:joins] && joins ? merge_joins(scope[:joins], joins) : (joins || scope && scope[:joins])
+            case merged_joins
+            when Symbol, Hash, Array
+              if code_type == :array_of_strings && array_of_strings?(merged_joins)
+                merged_joins.each { |merged_join| sql << " #{merged_join} " unless sql.include?(merged_join) }
+              else
+                join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, merged_joins, nil)
+                join_dependency.join_associations.each do |assoc|
+                  join_sql = assoc.association_join
+                  sql << " #{join_sql} " unless sql.include?(join_sql)
+                end
+              end
+            when String
+              sql << " #{merged_joins} " if merged_joins && !sql.include?(merged_joins)
+            end
+          else
+            options = options_or_joins
+            scope = scope(:find) if :auto == scope
+            [(scope && scope[:joins]), options[:joins]].each do |join|
+              case join
+              when Symbol, Hash, Array
+                join_dependency = ActiveRecord::Associations::ClassMethods::InnerJoinDependency.new(self, join, nil)
+                join_dependency.join_associations.each do |assoc|
+                  join_sql = assoc.association_join
+                  sql << " #{join_sql} " unless sql.include?(join_sql)
+                end
+              else
+                sql << " #{join} " if join && !sql.include?(join)
+              end
+            end
+          end
+        end
+    end
+  end
+end

data/lib/searchlogic/active_record/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,172 @@
+module Searchlogic
+  module ActiveRecord
+    module ConnectionAdapters # :nodoc: all
+      module MysqlAdapter
+        # Date / time functions
+        def microseconds_sql(column_name)
+          "MICROSECOND(#{column_name})"
+        end
+        
+        def milliseconds_sql(column_name)
+          "(MICROSECOND(#{column_name}) / 1000)"
+        end
+        
+        def second_sql(column_name)
+          "SECOND(#{column_name})"
+        end
+        
+        def minute_sql(column_name)
+          "MINUTE(#{column_name})"
+        end
+        
+        def hour_sql(column_name)
+          "HOUR(#{column_name})"
+        end
+        
+        def day_of_week_sql(column_name)
+          "DAYOFWEEK(#{column_name})"
+        end
+        
+        def day_of_month_sql(column_name)
+          "DAYOFMONTH(#{column_name})"
+        end
+        
+        def day_of_year_sql(column_name)
+          "DAYOFYEAR(#{column_name})"
+        end
+        
+        def week_sql(column_name)
+          "WEEK(#{column_name}, 2)"
+        end
+        
+        def month_sql(column_name)
+          "MONTH(#{column_name})"
+        end
+        
+        def year_sql(column_name)
+          "YEAR(#{column_name})"
+        end
+        
+        # String functions
+        def char_length_sql(column_name)
+          "CHAR_LENGTH(#{column_name})"
+        end
+        
+        def lower_sql(column_name)
+          "LOWER(#{column_name})"
+        end
+        
+        def ltrim_sql(column_name)
+          "LTRIM(#{column_name})"
+        end
+        
+        def md5_sql(column_name)
+          "MD5(#{column_name})"
+        end
+        
+        def rtrim_sql(column_name)
+          "RTRIM(#{column_name})"
+        end
+        
+        def trim_sql(column_name)
+          "TRIM(#{column_name})"
+        end
+        
+        def upper_sql(column_name)
+          "UPPER(#{column_name})"
+        end
+        
+        # Number functions
+        def absolute_sql(column_name)
+          "ABS(#{column_name})"
+        end
+        
+        def acos_sql(column_name)
+          "ACOS(#{column_name})"
+        end
+        
+        def asin_sql(column_name)
+          "ASIN(#{column_name})"
+        end
+        
+        def atan_sql(column_name)
+          "ATAN(#{column_name})"
+        end
+        
+        def ceil_sql(column_name)
+          "CEIL(#{column_name})"
+        end
+        
+        def cos_sql(column_name)
+          "COS(#{column_name})"
+        end
+        
+        def cot_sql(column_name)
+          "COT(#{column_name})"
+        end
+        
+        def degrees_sql(column_name)
+          "DEGREES(#{column_name})"
+        end
+        
+        def exp_sql(column_name)
+          "EXP(#{column_name})"
+        end
+        
+        def floor_sql(column_name)
+          "FLOOR(#{column_name})"
+        end
+        
+        def hex_sql(column_name)
+          "HEX(#{column_name})"
+        end
+        
+        def ln_sql(column_name)
+          "LN(#{column_name})"
+        end
+        
+        def log_sql(column_name)
+          "LOG(#{column_name})"
+        end
+        
+        def log2_sql(column_name)
+          "LOG2(#{column_name})"
+        end
+        
+        def log10_sql(column_name)
+          "LOG10(#{column_name})"
+        end
+        
+        def octal_sql(column_name)
+          "OCT(#{column_name})"
+        end
+        
+        def radians_sql(column_name)
+          "RADIANS(#{column_name})"
+        end
+        
+        def round_sql(column_name)
+          "ROUND(#{column_name})"
+        end
+        
+        def sign_sql(column_name)
+          "SIGN(#{column_name})"
+        end
+        
+        def sin_sql(column_name)
+          "SIN(#{column_name})"
+        end
+        
+        def square_root_sql(column_name)
+          "SQRT(#{column_name})"
+        end
+        
+        def tan_sql(column_name)
+          "TAN(#{column_name})"
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:include, Searchlogic::ActiveRecord::ConnectionAdapters::MysqlAdapter)