schof-searchlogic 0.0.2

data/lib/searchlogic/modifiers/second.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Modifiers
+    class Second < Base
+      class << self
+        def modifier_names
+          super + ["sec"]
+        end
+        
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/sign.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module Modifiers
+    class Sign < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/sin.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module Modifiers
+    class Sin < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/square_root.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Modifiers
+    class SquareRoot < Base
+      class << self
+        def modifier_names
+          super + ["sqrt", "sq_rt"]
+        end
+        
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/sum.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module Modifiers
+    class Sum < Base
+      class << self
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/tan.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Modifiers
+    class Tan < Base
+      class << self
+        def modifier_names
+          super + ["tangent"]
+        end
+        
+        def return_type
+          :float
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/trim.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Modifiers
+    class Trim < Base
+      class << self
+        def modifier_names
+          super + ["strip"]
+        end
+        
+        def return_type
+          :string
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/upper.rb

@@ -0,0 +1,15 @@
+module Searchlogic
+  module Modifiers
+    class Upper < Base
+      class << self
+        def modifier_names
+          super + ["upcase", "ucase"]
+        end
+        
+        def return_type
+          :string
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/week.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module Modifiers
+    class Week < Base
+      class << self
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/modifiers/year.rb

@@ -0,0 +1,11 @@
+module Searchlogic
+  module Modifiers
+    class Year < Base
+      class << self
+        def return_type
+          :integer
+        end
+      end
+    end
+  end
+end

data/lib/searchlogic/search/base.rb

@@ -0,0 +1,148 @@
+module Searchlogic #:nodoc:
+  module Search #:nodoc:
+    # = Searchlogic
+    #
+    # Please refer the README.rdoc for usage, examples, and installation.
+    class Base
+      include Searchlogic::Shared::Utilities
+      include Searchlogic::Shared::VirtualClasses
+      
+      # Options ActiveRecord allows when searching
+      AR_FIND_OPTIONS = ::ActiveRecord::Base.valid_find_options
+      
+      # Options ActiveRecord allows when performing calculations
+      AR_CALCULATIONS_OPTIONS = (::ActiveRecord::Base.valid_calculations_options - [:select, :limit, :offset, :order, :group, :include])
+      
+      AR_OPTIONS = (AR_FIND_OPTIONS + AR_CALCULATIONS_OPTIONS).uniq
+      
+      # Options that ActiveRecord doesn't suppport, but Searchlogic does
+      SPECIAL_FIND_OPTIONS = [:order_by, :order_as, :page, :per_page, :priority_order, :priority_order_by, :priority_order_as]
+      
+      # Valid options you can use when searching
+      OPTIONS = SPECIAL_FIND_OPTIONS + AR_OPTIONS # the order is very important, these options get set in this order
+      
+      attr_accessor *AR_OPTIONS
+      attr_writer :scope
+      
+      class << self
+        # Used in the ActiveRecord methods to determine if Searchlogic should get involved or not.
+        # This keeps Searchlogic out of the way unless it is needed.
+        def needed?(model_class, options)
+          return false if options.blank?
+          
+          SPECIAL_FIND_OPTIONS.each do |option|
+            return true if options.symbolize_keys.keys.include?(option)
+          end
+                    
+          Searchlogic::Conditions::Base.needed?(model_class, options[:conditions])
+        end
+      end
+      
+      def initialize(init_options = {})
+        self.options = init_options
+      end
+      
+      # Flag to determine if searchlogic is acting as a filter for the ActiveRecord search methods.
+      # By filter it means that searchlogic is being used on the default ActiveRecord search methods, like all, count, find(:all), first, etc.
+      def acting_as_filter=(value)
+        @acting_as_filter = value
+      end
+      
+      # See acting_as_filter=
+      def acting_as_filter?
+        @acting_as_filter == true
+      end
+      
+      # Specific implementation of cloning
+      def clone
+        options = {}
+        (AR_OPTIONS - [:conditions]).each { |option| options[option] = instance_variable_get("@#{option}") }
+        options[:conditions] = conditions.conditions
+        SPECIAL_FIND_OPTIONS.each { |option| options[option] = send(option) }
+        obj = self.class.new(options)
+        obj.protect = protected?
+        obj.scope = scope
+        obj
+      end
+      alias_method :dup, :clone
+      
+      # Makes using searchlogic in the console less annoying and keeps the output meaningful and useful
+      def inspect
+        current_find_options = {}
+        (AR_OPTIONS - [:conditions]).each do |option|
+          value = send(option)
+          next if value.nil?
+          current_find_options[option] = value
+        end
+        conditions_value = conditions.conditions
+        current_find_options[:conditions] = conditions_value unless conditions_value.blank?
+        current_find_options[:scope] = scope unless scope.blank?
+        "#<#{klass}Search #{current_find_options.inspect}>"
+      end
+      
+      # Merges all joins together, including the scopes joins for
+      def joins
+        all_joins = (safe_to_array(conditions.auto_joins) + safe_to_array(order_by_auto_joins) + safe_to_array(priority_order_by_auto_joins) + safe_to_array(@joins)).uniq
+        all_joins.size <= 1 ? all_joins.first : all_joins
+      end
+      
+      def limit=(value)
+        @set_limit = true
+        @limit = value.blank? || value == 0 ? nil : value.to_i
+      end
+      
+      def limit
+        @limit ||= Config.search.per_page if !acting_as_filter? && !@set_limit
+        @limit
+      end
+      
+      def offset=(value)
+        @offset = value.blank? ? nil : value.to_i
+      end
+
+      def options=(values)
+        return unless values.is_a?(Hash)
+        values.symbolize_keys.fast_assert_valid_keys(OPTIONS)
+        values.each { |key, value| send("#{key}=", value) }
+      end
+      
+      # Sanitizes everything down into options ActiveRecord::Base.find can understand
+      def sanitize(searching = true)  
+        find_options = {}
+        
+        (searching ? AR_FIND_OPTIONS : AR_CALCULATIONS_OPTIONS).each do |find_option|
+          value = send(find_option)
+          next if value.blank?
+          find_options[find_option] = value
+        end
+        
+        find_options
+      end
+      
+      def select
+        @select ||= "DISTINCT #{klass.connection.quote_table_name(klass.table_name)}.*" if !joins.blank? && Config.search.remove_duplicates? && klass.connection.adapter_name != "PostgreSQL"
+        @select
+      end
+      
+      def scope
+        @scope ||= {}
+      end
+      
+      private
+        def safe_to_array(o)
+          case o
+          when NilClass
+            []
+          when Array
+            o
+          else
+            [o]
+          end
+        end
+        
+        def array_of_strings?(o)
+          o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
+        end
+    end
+  end
+end

data/lib/searchlogic/search/conditions.rb

@@ -0,0 +1,53 @@
+module Searchlogic
+  module Search
+    # = Searchlogic Conditions
+    #
+    # Implements all of the conditions functionality into a searchlogic search. All of this functonality is extracted out into its own class Searchlogic::Conditions::Base. This is a separate module to help keep the code
+    # clean and organized.
+    module Conditions
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :initialize, :conditions
+          alias_method_chain :conditions=, :conditions
+          alias_method_chain :sanitize, :conditions
+        end
+      end
+      
+      def initialize_with_conditions(init_options = {})
+        self.conditions = Searchlogic::Conditions::Base.create_virtual_class(klass).new
+        initialize_without_conditions(init_options)
+      end
+      
+      # Sets conditions on the search. Accepts a hash or a Searchlogic::Conditions::Base object.
+      #
+      # === Examples
+      #
+      #   search.conditions = {:first_name_like => "Ben"}
+      #   search.conditions = User.new_conditions
+      #
+      # or to set a scope
+      #
+      #   search.conditions = "user_group_id = 6"
+      #
+      # now you can create the rest of your search and your "scope" will get merged into your final SQL.
+      # What this does is determine if the value a hash or a conditions object, if not it sets it up as a scope.
+      def conditions_with_conditions=(values)
+        case values
+        when Searchlogic::Conditions::Base
+          @conditions = values
+        else
+          @conditions.conditions = values
+        end
+      end
+      
+      def sanitize_with_conditions(searching = true) # :nodoc:
+        find_options = sanitize_without_conditions(searching)
+        if conditions_obj = find_options.delete(:conditions)
+          new_conditions = conditions_obj.sanitize
+          find_options[:conditions] = new_conditions unless new_conditions.blank?
+        end
+        find_options
+      end
+    end
+  end
+end

data/lib/searchlogic/search/ordering.rb

@@ -0,0 +1,244 @@
+module Searchlogic
+  module Search
+    # = Search Ordering
+    #
+    # The purpose of this module is to provide easy ordering for your searches. All that these options do is
+    # build :order for you. This plays a huge part in ordering your data on the interface. See the options and examples below. The readme also touches on ordering. It's pretty simple thought:
+    #
+    # === Examples
+    #
+    #   search.order_by = :id
+    #   search.order_by = [:id, :first_name]
+    #   search.order_by = {:user_group => :name}
+    #   search.order_by = [:id, {:user_group => :name}]
+    #   search.order_by = {:user_group => {:account => :name}} # you can traverse through all of your relationships
+    #
+    #   search.order_as = "DESC"
+    #   search.order_as = "ASC"
+    module Ordering
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :order=, :ordering
+          alias_method_chain :sanitize, :ordering
+          attr_reader :priority_order
+        end
+      end
+      
+      def order_with_ordering=(value) # :nodoc
+        @order_by = nil
+        @order_as = nil
+        @order_by_auto_joins = nil
+        self.order_without_ordering = value
+      end
+      
+      # Convenience method for determining if the ordering is ascending
+      def asc?
+        !desc?
+      end
+      
+      # Convenience method for determining if the ordering is descending
+      def desc?
+        return false if order_as.nil?
+        order_as == "DESC"
+      end
+      
+      # Determines how the search is being ordered: as DESC or ASC
+      def order_as
+        return if order.blank?
+        return @order_as if @order_as
+        
+        case order
+        when /ASC$/i
+          @order_as = "ASC"
+        when /DESC$/i 
+          @order_as = "DESC"
+        else
+          nil
+        end
+      end
+      
+      # Sets how the results will be ordered: ASC or DESC
+      def order_as=(value)
+        value = value.blank? ? nil : value.to_s.upcase
+        raise(ArgumentError, "order_as only accepts a blank string / nil or a string as 'ASC' or 'DESC'") if !value.blank? && !["ASC", "DESC"].include?(value)
+        if @order_by
+          @order = order_by_to_order(@order_by, value)
+        elsif order
+          @order.gsub!(/(ASC|DESC)/i, value)
+        end
+        @order_as = value
+      end
+      
+      # Determines by what columns the search is being ordered. This is nifty in that is reverse engineers the order SQL to determine this, only
+      # if you haven't explicitly set the order_by option yourself.
+      def order_by
+        return if order.blank?
+        @order_by ||= order_to_order_by(order)
+      end
+      
+      # Lets you set how to order the data
+      #
+      # === Examples
+      #
+      # In these examples "ASC" is determined by the value of order_as
+      #
+      #   order_by = :id # => users.id ASC
+      #   order_by = [:id, name] # => users.id ASC, user.name ASC
+      #   order_by = [:id, {:user_group => :name}] # => users.id ASC, user_groups.name ASC
+      def order_by=(value)  
+        @order_by_auto_joins = nil
+        @order_by = get_order_by_value(value)
+        @order = order_by_to_order(@order_by, @order_as)
+        @order_by
+      end
+      
+      # Returns the joins neccessary for the "order" statement so that we don't get an SQL error
+      def order_by_auto_joins
+        @order_by_auto_joins ||= build_order_by_auto_joins(order_by)
+      end
+      
+      # Let's you set a priority order. Meaning this will get ordered first before anything else, but is unnoticeable and abstracted out from your regular order. For example, lets say you have a model called Product
+      # that had a "featured" boolean column. You want to order the products by the price, quantity, etc., but you want the featured products to always be first.
+      #
+      # Without a priority order your controller would get cluttered and your code would be much more complicated. All of your order_by_link methods would have to be order_by_link [:featured, :price], :text => "Price"
+      # Your order_by_link methods alternate between ASC and DESC, so the featured products would jump from the top the bottom. It presents a lot of "work arounds". So priority_order solves this.
+      def priority_order=(value)
+        @priority_order = value
+      end
+      
+      # Same as order_by but for your priority order. See priority_order= for more informaton on priority_order.
+      def priority_order_by
+        return if priority_order.blank?
+        @priority_order_by ||= order_to_order_by(priority_order)
+      end
+      
+      # Same as order_by= but for your priority order. See priority_order= for more informaton on priority_order.
+      def priority_order_by=(value)
+        @priority_order_by_auto_joins = nil
+        @priority_order_by = get_order_by_value(value)
+        @priority_order = order_by_to_order(@priority_order_by, @priority_order_as)
+        @priority_order_by
+      end
+      
+      # Same as order_as but for your priority order. See priority_order= for more informaton on priority_order.
+      def priority_order_as
+        return if priority_order.blank?
+        return @priority_order_as if @priority_order_as
+        
+        case priority_order
+        when /ASC$/i
+          @priority_order_as = "ASC"
+        when /DESC$/i 
+          @priority_order_as = "DESC"
+        else
+          nil
+        end
+      end
+      
+      # Same as order_as= but for your priority order. See priority_order= for more informaton on priority_order.
+      def priority_order_as=(value)
+        value = value.blank? ? nil : value.to_s.upcase
+        raise(ArgumentError, "priority_order_as only accepts a blank string / nil or a string as 'ASC' or 'DESC'") if !value.blank? && !["ASC", "DESC"].include?(value)
+        if @priority_order_by
+          @priority_order = order_by_to_order(@priority_order_by, value)
+        elsif priority_order
+          @priority_order.gsub!(/(ASC|DESC)/i, value)
+        end
+        @priority_order_as = value
+      end
+      
+      def priority_order_by_auto_joins
+        @priority_order_by_auto_joins ||= build_order_by_auto_joins(priority_order_by)
+      end
+      
+      def sanitize_with_ordering(searching = true)
+        find_options = sanitize_without_ordering(searching)
+        unless priority_order.blank?
+          order_parts = [priority_order, find_options[:order]].compact
+          find_options[:order] = order_parts.join(", ")
+        end
+        find_options
+      end
+      
+      private
+        def order_by_to_order(order_by, order_as, alt_klass = nil)
+          return if order_by.blank?
+          
+          k = alt_klass || klass
+          table_name = k.table_name
+          sql_parts = []
+          
+          case order_by
+          when Array
+            order_by.each { |part| sql_parts << order_by_to_order(part, order_as, alt_klass) }
+          when Hash
+            raise(ArgumentError, "when passing a hash to order_by you must only have 1 key: {:user_group => :name} not {:user_group => :name, :user_group => :id}. The latter should be [{:user_group => :name}, {:user_group => :id}]") if order_by.keys.size != 1
+            key = order_by.keys.first
+            reflection = k.reflect_on_association(key.to_sym)
+            value = order_by.values.first
+            sql_parts << order_by_to_order(value, order_as, reflection.klass)
+          when Symbol, String
+            part = "#{quote_table_name(table_name)}.#{quote_column_name(order_by)}"
+            part += " #{order_as}" unless order_as.blank?
+            sql_parts << part
+          end
+          
+          sql_parts.join(", ")
+        end
+        
+        def order_to_order_by(order)
+          # Reversege engineer order, only go 1 level deep with relationships, anything beyond that is probably excessive and not good for performance
+          order_parts = order.split(",").collect do |part|
+            part.strip!
+            part.gsub!(/ (ASC|DESC)$/i, "")
+            part.gsub!(/(.*)\./, "")
+            table_name = ($1 ? $1.gsub(/[^a-z0-9_]/i, "") : nil)
+            part.gsub!(/[^a-z0-9_]/i, "")
+            reflection = nil
+            if table_name && table_name != klass.table_name
+              reflection = klass.reflect_on_association(table_name.to_sym) || klass.reflect_on_association(table_name.singularize.to_sym)
+              next unless reflection
+              {reflection.name.to_s => part}
+            else
+              part
+            end
+          end.compact
+          order_parts.size <= 1 ? order_parts.first : order_parts
+        end
+        
+        def build_order_by_auto_joins(order_by_value)
+          case order_by_value
+          when Array
+            order_by_value.collect { |value| build_order_by_auto_joins(value) }.uniq.compact
+          when Hash
+            key = order_by_value.keys.first
+            value = order_by_value.values.first
+            case value
+            when Hash
+              {key.to_sym => build_order_by_auto_joins(value)}
+            else
+              key.to_sym
+            end
+          else
+            nil
+          end
+        end
+        
+        def get_order_by_value(value)
+          Marshal.load(value.unpack("m").first) rescue value
+        end
+        
+        def quote_column_name(column_name)
+          klass_connection.quote_column_name(column_name)
+        end
+
+        def quote_table_name(table_name)
+          klass_connection.quote_table_name(table_name)
+        end
+        
+        def klass_connection
+          @connection ||= klass.connection
+        end
+    end
+  end
+end