searchgasm 0.9.6 → 0.9.7

data/lib/searchgasm/search/conditions.rb

@@ -1,171 +1,47 @@
-module BinaryLogic
-  module Searchgasm
-    module Search
-      class Conditions
-        include Utilities
-        
-        attr_accessor :klass, :protect, :relationship_name, :scope
-        
-        class << self
-          def register_condition(klass)
-            raise(ArgumentError, "You can only register conditions that extend BinaryLogic::Searchgasm::Search::ConditionTypes::Condition") unless klass.ancestors.include?(Condition)
-            conditions << klass unless conditions.include?(klass)
-          end
-          
-          def conditions
-            @@conditions ||= []
-          end
-          
-          def needed?(klass, conditions)
-            if conditions.is_a?(Hash)
-              conditions.stringify_keys.keys.each do |condition|
-                return true unless klass.column_names.include?(condition)
-              end
-            end
-            
-            false
-          end
+module Searchgasm
+  module Search
+    module Conditions
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :initialize, :conditions
+          alias_method_chain :conditions=, :conditions
+          alias_method_chain :include, :conditions
+          alias_method_chain :sanitize, :conditions
         end
-        
-        def initialize(klass, init_values = {})
-          self.klass = klass
-          add_klass_conditions!
-          add_column_conditions!
-          add_associations!
-          self.value = init_values
-        end
-        
-        # Setup methods for searching
-        [:all, :average, :calculate, :count, :find, :first, :maximum, :minimum, :sum].each do |method|
-          class_eval <<-end_eval
-            def #{method}(*args)
-              self.value = args.extract_options!
-              args << {:conditions => sanitize}
-              klass.#{method}(*args)
-            end
-          end_eval
-        end
-        
-        def assert_valid_values(values)
-          keys = condition_names.collect { |condition_name| condition_name.to_sym }
-          keys += klass.reflect_on_all_associations.collect { |association| association.name }
-          values.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 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
-        
-        def objects
-          @objects ||= []
-        end
-        
-        def protect?
-          protect == true
-        end
-        
-        def sanitize
-          conditions = merge_conditions(*objects.collect { |object| object.sanitize })
-          return scope if conditions.blank?
-          merge_conditions(conditions, scope)
-        end
-        
-        def value=(values)
-          case values
-          when Hash
-            assert_valid_values(values)
-            values.each { |condition, value| send("#{condition}=", value) }
-          else
-            raise(ArgumentError, "You can not set a scope or pass SQL while the search is being protected") if protect?
-            self.scope = values
-          end
-        end
-        
-        def value
-          values_hash = {}
-          objects.each do |object|
-            next unless object.explicitly_set_value?
-            values_hash[object.name.to_sym] = object.value
-          end
-          values_hash
+      end
+      
+      def initialize_with_conditions(klass, init_options = {})
+        self.conditions = Searchgasm::Conditions::Base.new(klass)
+        initialize_without_conditions(klass, init_options)
+      end
+      
+      # Sets conditions on the search. Accepts a hash or a Searchgasm::Conditions::Base object.
+      def conditions_with_conditions=(values)
+        case values
+        when Searchgasm::Conditions::Base
+          @conditions = values
+        else
+          @conditions.conditions = values
         end
-        
-        private
-          def add_associations!
-            klass.reflect_on_all_associations.each do |association|
-              self.class.class_eval <<-end_eval
-                def #{association.name}
-                  if @#{association.name}.nil?
-                    @#{association.name} = self.class.new(#{association.class_name})
-                    @#{association.name}.relationship_name = "#{association.name}"
-                    self.objects << @#{association.name}
-                  end
-                  @#{association.name}
-                end
-              
-                def #{association.name}=(value); #{association.name}.value = value; 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|
-                name = condition.name_for_column(column)
-                next if name.blank?
-                add_condition!(condition, name, column)
-                condition.aliases_for_column(column).each { |alias_name| add_condition_alias!(alias_name, name) }
-              end
-            end
-          end
-          
-          def add_condition!(condition, name, column = nil)
-            self.condition_names << name
-            self.class.class_eval <<-end_eval
-              def #{name}_object
-                if @#{name}.nil?
-                  @#{name} = #{condition.name}.new(klass#{column.nil? ? "" : ", \"#{column.name}\""})
-                  self.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)
-            self.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
+      end
+      
+      def include_with_conditions
+        includes = [include_without_conditions, conditions.includes].flatten.compact.uniq
+        includes.blank? ? nil : (includes.size == 1 ? includes.first : includes)
+      end
+      
+      def sanitize_with_conditions(for_method = nil)
+        find_options = sanitize_without_conditions(for_method)
+        find_options[:conditions] = find_options[:conditions].sanitize if find_options[:conditions]
+        find_options
+      end
+      
+      def scope
+        conditions.scope
+      end
+      
+      def scope=(value)
+        conditions.scope = value
       end
     end
   end

data/lib/searchgasm/search/ordering.rb

@@ -0,0 +1,149 @@
+module Searchgasm
+  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 Searchgasm::Helpers::SearchHelper for more information.
+    module Ordering
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :include, :ordering
+          alias_method_chain :order=, :ordering
+        end
+      end
+      
+      def include_with_ordering
+        includes = [include_without_ordering, order_by_includes].flatten.compact.uniq
+        includes.blank? ? nil : (includes.size == 1 ? includes.first : includes)
+      end
+      
+      def order_with_ordering=(value)
+        @order_by = 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?
+        order_as == "DESC"
+      end
+      
+      # Determines how the search is being ordered: as DESC or ASC
+      def order_as
+        return "ASC" if order.blank?
+        order =~ /ASC$/i ? "ASC" : "DESC"
+      end
+      
+      # Sets how the results will be ordered: ASC or DESC
+      def order_as=(value)
+        value = value.to_s.upcase
+        raise(ArgumentError, "order_as only accepts a string as ASC or DESC") unless ["ASC", "DESC"].include?(value)
+        
+        if order.blank?
+          self.order = order_by_to_order(order_by, value)
+        else
+          self.order.gsub!(/(ASC|DESC)/i, value)
+        end
+        
+        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 @order_by if @order_by
+        
+        if !order.blank?
+          # 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, "").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
+        else
+          klass.primary_key
+        end
+      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 = get_order_by_value(value)
+        @order = order_by_to_order(@order_by, order_as) # use @order so @order_by doesnt get reset
+        @order_by
+      end
+      
+      # Returns the includes neccessary for the "order" statement so that we don't get an SQL error
+      def order_by_includes
+        @order_by_includes ||= []
+        @order_by_includes.compact!
+        @order_by_includes.uniq!
+        @order_by_includes
+      end
+      
+      private
+        def order_by_to_order(order_by, order_as, alt_klass = nil, new_includes = [])
+          table_name = (alt_klass || klass).table_name
+          sql_parts = []
+          
+          case order_by
+          when Array
+            order_by.each { |part| sql_parts << order_by_to_order(part, order_as) }
+          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
+            k = order_by.keys.first
+            v = order_by.values.first
+            new_includes << k.to_sym
+            sql_parts << order_by_to_order(v, order_as, k.to_s.classify.constantize, new_includes)
+          when Symbol, String
+            new_include = build_order_by_includes(new_includes)
+            self.order_by_includes << new_include if new_include
+            sql_parts << "#{quote_table_name(table_name)}.#{quote_column_name(order_by)} #{order_as}"
+          end
+          
+          sql_parts.join(", ")
+        end
+        
+        def build_order_by_includes(includes)
+          return includes.first if includes.size <= 1
+          includes = includes.dup
+          
+          key = includes.shift
+          {key => build_order_by_includes(includes)}
+        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
+    end
+  end
+end

data/lib/searchgasm/search/pagination.rb

@@ -0,0 +1,69 @@
+module Searchgasm
+  module Search
+    module Pagination
+      def self.included(klass)
+        klass.class_eval do
+          alias_method_chain :limit=, :pagination
+          alias_method_chain :offset=, :pagination
+          alias_method :per_page, :limit
+          alias_method :per_page=, :limit=
+        end
+      end
+      
+      def limit_with_pagination=(value)
+        self.limit_without_pagination = value
+        self.page = @page unless @page.nil? # retry page now that the limit has changed
+        limit
+      end
+      
+      def offset_with_pagination=(value)
+        self.offset_without_pagination = value
+        @page = nil
+        offset
+      end
+      
+      def page
+        return 1 if offset.blank? || limit.blank?
+        (offset.to_f / limit).floor + 1
+      end
+      
+      def page=(value)
+        # Have to use @offset, since self.offset= resets @page
+        if value.nil?
+          @page = value
+          return @offset = value
+        end
+        
+        v = value.to_i
+        @page = v
+        
+        if limit.blank?
+          @offset = nil
+        else
+          v -= 1 unless v == 0
+          @offset = v * limit
+        end
+        value
+      end
+      
+      def page_count
+        return 1 if per_page.blank? || per_page <= 0
+        # Letting AR caching kick in with the count query
+        (count / per_page.to_f).ceil
+      end
+      alias_method :page_total, :page_count
+      
+      def next_page!
+        raise("You are on the last page") if page == page_count
+        self.page += 1
+        all
+      end
+      
+      def prev_page!
+        raise("You are on the first page") if page == 1
+        self.page -= 1
+        all
+      end
+    end
+  end
+end

data/lib/searchgasm/search/protection.rb

@@ -0,0 +1,61 @@
+module Searchgasm
+  module Search
+    module Protection
+      # Options that are allowed when protecting against SQL injections (still checked though)
+      SAFE_OPTIONS = Base::SPECIAL_FIND_OPTIONS + [:conditions, :limit, :offset]
+      
+      # Options that are not allowed, at all, when protecting against SQL injections
+      VULNERABLE_OPTIONS = Base::VALID_FIND_OPTIONS - SAFE_OPTIONS
+      
+      def self.included(klass)
+        klass.class_eval do
+          attr_reader :protect
+          alias_method_chain :options=, :protection
+        end
+      end
+      
+      def options_with_protection=(values)
+        return unless values.is_a?(Hash)
+        self.protect = values.delete(:protect) if values.has_key?(:protect) # make sure we do this first
+        frisk!(values) if protect?
+        self.options_without_protection = values
+      end
+      
+      def protect=(value)
+        conditions.protect = value
+        @protect = value
+      end
+      
+      def protect?
+        protect == true
+      end
+      
+      private
+        def order_by_safe?(order_by, alt_klass = nil)
+          return true if order_by.blank?
+          
+          k = alt_klass || klass
+          column_names = k.column_names
+          
+          [order_by].flatten.each do |column|
+            case column
+            when Hash
+              return false unless k.reflect_on_association(column.keys.first.to_sym)
+              return false unless order_by_safe?(column.values.first, column.keys.first.to_s.classify.constantize)
+            when Array
+              return false unless order_by_safe?(column)
+            else
+              return false unless column_names.include?(column.to_s)
+            end
+          end
+          
+          true
+        end
+        
+        def frisk!(options)
+          options.symbolize_keys.assert_valid_keys(SAFE_OPTIONS)
+          raise(ArgumentError, ":order_by can only contain colum names in the string, hash, or array format") unless order_by_safe?(get_order_by_value(options[:order_by]))
+        end
+    end    
+  end
+end

data/lib/searchgasm/utilities.rb

@@ -0,0 +1,30 @@
+module Searchgasm
+  module Utilities # :nodoc:
+    private
+      def merge_conditions(*conditions)
+        options = conditions.extract_options!
+        conditions.delete_if { |condition| condition.blank? }
+        return if conditions.blank?
+        return conditions.first if conditions.size == 1
+        
+        conditions_strs = []
+        conditions_subs = []
+        
+        conditions.each do |condition|
+          next if condition.blank?
+          arr_condition = [condition].flatten
+          conditions_strs << arr_condition.first
+          conditions_subs += arr_condition[1..-1]
+        end
+        
+        return if conditions_strs.blank?
+        
+        join = options[:any] ? "OR" : "AND"
+        conditions_str = "(#{conditions_strs.join(") #{join} (")})"
+        
+        return conditions_str if conditions_subs.blank?
+        
+        [conditions_str, *conditions_subs]
+      end
+  end
+end

data/lib/searchgasm/version.rb

@@ -21,61 +21,58 @@
 # CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-module BinaryLogic
-  
-  module Searchgasm
-    
-    # A class for describing the current version of a library. The version
-    # consists of three parts: the +major+ number, the +minor+ number, and the
-    # +tiny+ (or +patch+) number.
-    class Version
-      
-      include Comparable
+module Searchgasm
+  # = Version
+  #
+  # A class for describing the current version of a library. The version
+  # consists of three parts: the +major+ number, the +minor+ number, and the
+  # +tiny+ (or +patch+) number.
+  class Version
     
-      # A convenience method for instantiating a new Version instance with the
-      # given +major+, +minor+, and +tiny+ components.
-      def self.[](major, minor, tiny)
-        new(major, minor, tiny)
-      end
+    include Comparable
+  
+    # A convenience method for instantiating a new Version instance with the
+    # given +major+, +minor+, and +tiny+ components.
+    def self.[](major, minor, tiny)
+      new(major, minor, tiny)
+    end
 
-      attr_reader :major, :minor, :tiny
+    attr_reader :major, :minor, :tiny
 
-      # Create a new Version object with the given components.
-      def initialize(major, minor, tiny)
-        @major, @minor, @tiny = major, minor, tiny
-      end
+    # Create a new Version object with the given components.
+    def initialize(major, minor, tiny)
+      @major, @minor, @tiny = major, minor, tiny
+    end
 
-      # Compare this version to the given +version+ object.
-      def <=>(version)
-        to_i <=> version.to_i
-      end
+    # Compare this version to the given +version+ object.
+    def <=>(version)
+      to_i <=> version.to_i
+    end
 
-      # Converts this version object to a string, where each of the three
-      # version components are joined by the '.' character. E.g., 2.0.0.
-      def to_s
-        @to_s ||= [@major, @minor, @tiny].join(".")
-      end
+    # Converts this version object to a string, where each of the three
+    # version components are joined by the '.' character. E.g., 2.0.0.
+    def to_s
+      @to_s ||= [@major, @minor, @tiny].join(".")
+    end
 
-      # Converts this version to a canonical integer that may be compared
-      # against other version objects.
-      def to_i
-        @to_i ||= @major * 1_000_000 + @minor * 1_000 + @tiny
-      end
-      
-      def to_a
-        [@major, @minor, @tiny]
-      end
+    # Converts this version to a canonical integer that may be compared
+    # against other version objects.
+    def to_i
+      @to_i ||= @major * 1_000_000 + @minor * 1_000 + @tiny
+    end
+    
+    def to_a
+      [@major, @minor, @tiny]
+    end
 
-      MAJOR = 0
-      MINOR = 9
-      TINY  = 6
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 7
 
-      # The current version as a Version instance
-      CURRENT = new(MAJOR, MINOR, TINY)
-      # The current version as a String
-      STRING = CURRENT.to_s
-      
-    end
+    # The current version as a Version instance
+    CURRENT = new(MAJOR, MINOR, TINY)
+    # The current version as a String
+    STRING = CURRENT.to_s
     
   end