searchgasm 0.9.0

data/lib/searchgasm/search/base.rb

@@ -0,0 +1,142 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      class Base
+        include Utilities
+        
+        SPECIAL_FIND_OPTIONS = [:order_by, :order_as, :page, :per_page]
+        VALID_FIND_OPTIONS = ::ActiveRecord::Base.valid_find_options + SPECIAL_FIND_OPTIONS
+        
+        attr_accessor :klass
+        attr_reader :conditions
+        attr_writer :options
+        
+        def initialize(klass, options = {})
+          self.klass = klass
+          self.conditions = Conditions.new(klass)
+          self.options = options
+        end
+        
+        (::ActiveRecord::Base.valid_find_options - [:conditions]).each do |option|
+          class_eval <<-SRC
+            def #{option}(sanitize = false); options[:#{option}]; end
+            def #{option}=(value); self.options[:#{option}] = value; end
+          SRC
+        end
+        
+        alias_method :per_page, :limit
+        
+        def all
+          klass.all(sanitize)
+        end
+        alias_method :search, :all
+        
+        def conditions=(value)
+          case value
+          when Conditions
+            @conditions = value
+          else
+            @conditions.value = value
+          end
+        end
+        
+        def conditions(sanitize = false)
+          sanitize ? @conditions.sanitize : @conditions
+        end
+        
+        def find(target)
+          case target
+          when :all then all
+          when :first then first
+          else raise(ArgumentError, "The argument must be :all or :first")
+          end
+        end
+        
+        def first
+          klass.first(sanitize)
+        end
+        
+        def include(sanitize = false)
+          includes = [self.options[:include], conditions.includes].flatten.compact
+          includes.blank? ? nil : (includes.size == 1 ? includes.first : includes)
+        end
+        
+        def limit=(value)
+          return options[:limit] = nil if value.nil? || value == 0
+          
+          old_limit = options[:limit]
+          options[:limit] = value
+          self.page = @page if !@page.blank? # retry page now that limit is set
+          value
+        end
+        alias_method :per_page=, :limit=
+        
+        def options
+          @options ||= {}
+        end
+        
+        def options=(options)
+          return unless options.is_a?(Hash)
+          options.each { |option, value| send("#{option}=", value) }
+        end
+        
+        def order_as
+          return "DESC" if order.blank?
+          order =~ /ASC$/i ? "ASC" : "DESC"
+        end
+        
+        def order_as=(value)
+          # reset order
+        end
+        
+        def order_by
+          # need to return a cached value of order_by, not smart to figure it out from order
+        end
+        
+        def order_by=(value)
+          # do your magic here and set order approperiately
+        end
+        
+        def page
+          return 1 if offset.blank?
+          (offset.to_f / limit).ceil
+        end
+        
+        def page=(value)
+          return self.offset = nil if value.nil?
+          
+          if limit.blank?
+            @page = value
+          else
+            @page = nil
+            self.offset = value * limit
+          end
+          value
+        end
+        
+        def reset!
+          conditions.reset!
+          self.options = {}
+        end
+        
+        def sanitize
+          find_options = {}
+          ::ActiveRecord::Base.valid_find_options.each do |find_option|
+            value = send(find_option, true)
+            next if value.blank?
+            find_options[find_option] = value
+          end
+          find_options
+        end
+        
+        def scope
+          conditions.scope
+        end
+        
+        def scope=(value)
+          conditions.scope = value
+        end
+      end
+    end
+  end
+end

data/lib/searchgasm/search/condition.rb

@@ -0,0 +1,168 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      class Condition
+        include Utilities
+        
+        BLACKLISTED_WORDS = ('a'..'z').to_a + ["about", "an", "are", "as", "at", "be", "by", "com", "de", "en", "for", "from", "how", "in", "is", "it", "la", "of", "on", "or", "that", "the", "the", "this", "to", "und", "was", "what", "when", "where", "who", "will", "with", "www"] # from ranks.nl        
+        attr_accessor :column, :condition, :name, :klass
+        attr_reader :value
+        
+        class << self
+          def generate_name(column, condition)
+            name_parts = []
+            name_parts << (column.is_a?(String) ? column : column.name) unless column.blank?
+            name_parts << condition unless condition.blank?
+            name_parts.join("_")
+          end
+        end
+        
+        def initialize(condition, klass, column = nil)
+          raise(ArgumentError, "#{klass.name} must acts_as_tree to use the :#{condition} condition") if requires_tree?(condition) && !has_tree?(klass)
+          
+          self.condition = condition
+          self.name = self.class.generate_name(column, condition)
+          self.klass = klass
+          self.column = column.is_a?(String) ? klass.columns_hash[column] : column
+        end
+        
+        def explicitly_set_value=(value)
+          @explicitly_set_value = value
+        end
+        
+        # Need this if someone wants to actually use nil in a meaningful way
+        def explicitly_set_value?
+          @explicitly_set_value == true
+        end
+        
+        def has_tree?(klass = klass)
+          !klass.reflect_on_association(:parent).nil?
+        end
+        
+        def ignore_blanks?
+          ![:equals, :does_not_equal].include?(condition)
+        end
+        
+        def quote_column_name(column_name)
+          klass.connection.quote_column_name(column_name)
+        end
+        
+        def quoted_column_name
+          quote_column_name(column.name)
+        end
+        
+        def requires_tree?(condition = condition)
+          [:child_of, :sibling_of, :descendent_of, :inclusive_descendent_of].include?(condition)
+        end
+        
+        def sanitize
+          return unless explicitly_set_value?
+          v = value
+          v = v.utc if false && [:time, :timestamp, :datetime].include?(column.type) && klass.time_zone_aware_attributes && !klass.skip_time_zone_conversion_for_attributes.include?(column.name.to_sym)
+          generate_conditions(condition, v)
+        end
+        
+        def table_name
+          klass.connection.quote_table_name(klass.table_name)
+        end
+        
+        def value
+          @value.is_a?(String) ? column.type_cast(@value) : @value
+        end
+        
+        def value=(v)
+          return if ignore_blanks? && v.blank?
+          self.explicitly_set_value = true
+          @value = v
+        end
+        
+        private
+          def generate_conditions(condition, value)
+            if [:equals, :does_not_equal].include?(condition)
+              # Let ActiveRecord handle this
+              sql = klass.send(:sanitize_sql_hash_for_conditions, {column.name => value})
+              if condition == :does_not_equal
+                sql.gsub!(/ IS /, " IS NOT ")
+                sql.gsub!(/ BETWEEN /, " NOT BETWEEN ")
+                sql.gsub!(/ IN /, " NOT IN ")
+                sql.gsub!(/=/, "!=")
+              end
+              return [sql]
+            end
+            
+            strs = []
+            subs = []
+            
+            if value.is_a?(Array)
+              merge_conditions(*value.collect { |v| generate_conditions(condition, v) })
+            else
+              case condition
+              when :begins_with
+                search_parts = value.split(/ /)
+                search_parts.each do |search_part|
+                  strs << "#{table_name}.#{quoted_column_name} LIKE ?"
+                  subs << "#{search_part}%"
+                end
+              when :contains
+                strs << "#{table_name}.#{quoted_column_name} LIKE ?"
+                subs << "%#{value}%"
+              when :ends_with
+                search_parts = value.split(/ /)
+                search_parts.each do |search_part|
+                  strs << "#{table_name}.#{quoted_column_name} LIKE ?"
+                  subs << "%#{search_part}"
+                end
+              when :greater_than
+                strs << "#{table_name}.#{quoted_column_name} > ?"
+                subs << value
+              when :greater_than_or_equal_to
+                strs << "#{table_name}.#{quoted_column_name} >= ?"
+                subs << value
+              when :keywords
+                search_parts = value.gsub(/,/, " ").split(/ /).collect { |word| word.downcase.gsub(/[^[:alnum:]]/, ''); }.uniq.select { |word| !BLACKLISTED_WORDS.include?(word.downcase) && !word.blank? }
+                search_parts.each do |search_part|
+                  strs << "#{table_name}.#{quoted_column_name} LIKE ?"
+                  subs << "%#{search_part}%"
+                end
+              when :less_than
+                strs << "#{table_name}.#{quoted_column_name} < ?"
+                subs << value
+              when :less_than_or_equal_to
+                strs << "#{table_name}.#{quoted_column_name} <= ?"
+                subs << value
+              when :child_of
+                parent_association = klass.reflect_on_association(:parent)
+                foreign_key_name = (parent_association && parent_association.options[:foreign_key]) || "parent_id"
+                strs << "#{table_name}.#{quote_column_name(foreign_key_name)} = ?"
+                subs << value
+              when :sibling_of
+                parent_association = klass.reflect_on_association(:parent)
+                foreign_key_name = (parent_association && parent_association.options[:foreign_key]) || "parent_id"
+                parent_id = klass.find(value).send(foreign_key_name)
+                return generate_conditions(:child_of, parent_id)
+              when :descendent_of
+                # Wish I knew how to do this in SQL
+                root = klass.find(value) rescue return
+                condition_strs = []
+                all_children_ids(root).each do |child_id|
+                  condition_strs << "#{table_name}.#{quote_column_name(klass.primary_key)} = ?"
+                  subs << child_id
+                end
+                strs << condition_strs.join(" OR ")
+              when :inclusive_descendent_of
+                return merge_conditions(["#{table_name}.#{quote_column_name(klass.primary_key)} = ?", value], generate_conditions(:descendent_of, value), :any => true)
+              end
+            
+              [strs.join(" AND "), *subs]
+            end
+          end
+          
+          def all_children_ids(record)
+            ids = record.children.collect { |child| child.send(klass.primary_key) }
+            record.children.each { |child| ids += all_children_ids(child) }
+            ids
+          end
+      end
+    end
+  end
+end

data/lib/searchgasm/search/conditions.rb

@@ -0,0 +1,154 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      class Conditions
+        include Utilities
+        
+        attr_accessor :klass, :relationship_name, :scope
+        
+        class << self
+          def conditions_for_column_type(type)
+            condition_names = [:equals, :does_not_equal]
+            case type
+            when :string, :text
+              condition_names += [:begins_with, :contains, :keywords, :ends_with]
+            when :integer, :float, :decimal, :datetime, :timestamp, :time, :date
+              condition_names += [:greater_than, :greater_than_or_equal_to, :less_than, :less_than_or_equal_to]
+            end
+            condition_names
+          end
+        
+          def alias_conditions(condition)
+            case condition
+            when :equals                    then  ["", :is]
+            when :does_not_equal            then  [:is_not, :not]
+            when :begins_with               then  [:starts_with]
+            when :contains                  then  [:like]
+            when :greater_than              then  [:gt, :after]
+            when :greater_than_or_equal_to  then  [:at_least, :gte]
+            when :less_than                 then  [:lt, :before]
+            when :less_than_or_equal_to     then  [:at_most, :lte]
+            else                                  []
+            end
+          end
+        end
+        
+        def initialize(klass, values = {})
+          self.klass = klass
+          klass.columns.each { |column| add_conditions_for_column!(column) }
+          klass.reflect_on_all_associations.each { |association| add_association!(association)  }
+          self.value = values
+        end
+        
+        def associations
+          objects.select { |object| object.is_a?(self.class) }
+        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 reset!
+          dupped_objects = objects.dup
+          dupped_objects.each do |object|
+            if object.is_a?(self.class)
+              send("reset_#{object.relationship_name}!")
+            else
+              send("reset_#{object.name}!")
+            end
+          end
+          objects
+        end
+        
+        def sanitize
+          sanitized_objects = merge_conditions(*objects.collect { |object| object.sanitize })
+          return scope if sanitized_objects.blank?
+          merge_conditions(sanitized_objects, scope)
+        end
+        
+        def value=(conditions)
+          reset!
+          self.scope = nil
+          
+          case conditions
+          when Hash
+            conditions.each { |condition, value| send("#{condition}=", value) }
+          else
+            self.scope = conditions
+          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
+        
+        private
+          def add_association!(association)
+            self.class.class_eval <<-SRC
+              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
+            SRC
+            
+            association.name
+          end
+          
+          def add_conditions_for_column!(column)
+            self.class.conditions_for_column_type(column.type).collect { |condition_name| add_condition!(condition_name, column) }
+          end
+          
+          def add_condition!(condition_name, column)
+            name = Condition.generate_name(column, condition_name)
+
+            # Define accessor methods
+            self.class.class_eval <<-SRC
+              def #{name}_object
+                if @#{name}.nil?
+                  @#{name} = Condition.new(:#{condition_name}, klass, "#{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
+            SRC
+            
+            # Define aliases
+            self.class.alias_conditions(condition_name).each do |alias_condition_name|
+              alias_name = Condition.generate_name(column, alias_condition_name)
+              self.class.class_eval do
+                alias_method alias_name, name
+                alias_method "#{alias_name}=", "#{name}="
+              end
+            end
+            
+            name
+          end
+      end
+    end
+  end
+end

data/lib/searchgasm/search/utilities.rb

@@ -0,0 +1,34 @@
+module BinaryLogic
+  module Searchgasm
+    module Search
+      module Utilities
+        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
+  end
+end

data/lib/searchgasm/version.rb

@@ -0,0 +1,82 @@
+# (The MIT License)
+# 
+# Copyright (c) 2008 Jamis Buck <jamis@37signals.com>,
+#               with modifications by Bruce Williams <bruce@fiveruns.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# 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
+    
+      # 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
+
+      # 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
+
+      # 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
+
+      MAJOR = 0
+      MINOR = 9
+      TINY  = 0
+
+      # The current version as a Version instance
+      CURRENT = new(MAJOR, MINOR, TINY)
+      # The current version as a String
+      STRING = CURRENT.to_s
+      
+    end
+    
+  end
+  
+end

data/lib/searchgasm.rb

@@ -0,0 +1,9 @@
+require "active_record"
+require "searchgasm/active_record/protection"
+require "searchgasm/active_record/base"
+require "searchgasm/active_record/associations"
+require "searchgasm/version"
+require "searchgasm/search/utilities"
+require "searchgasm/search/condition"
+require "searchgasm/search/conditions"
+require "searchgasm/search/base"