searchgasm 1.2.2 → 1.3.0

data/lib/searchgasm/active_record/connection_adapters/sqlite_adapter.rb

@@ -0,0 +1,54 @@
+module Searchgasm
+  module ActiveRecord
+    module ConnectionAdapters
+      module SQLiteAdapter
+        # Date functions
+        def microseconds_sql(column_name)
+          "((strftime('%f', #{column_name}) % 1) * 1000000)"
+        end
+        
+        def milliseconds_sql(column_name)
+          "((strftime('%f', #{column_name}) % 1) * 1000)"
+        end
+        
+        def second_sql(column_name)
+          "strftime('%S', #{column_name})"
+        end
+        
+        def minute_sql(column_name)
+          "strftime('%M', #{column_name})"
+        end
+        
+        def hour_sql(column_name)
+          "strftime('%H', #{column_name})"
+        end
+        
+        def day_of_week_sql(column_name)
+          "strftime('%w', #{column_name})"
+        end
+        
+        def day_of_month_sql(column_name)
+          "strftime('%d', #{column_name})"
+        end
+        
+        def day_of_year_sql(column_name)
+          "strftime('%j', #{column_name})"
+        end
+        
+        def week_sql(column_name)
+          "strftime('%W', #{column_name})"
+        end
+        
+        def month_sql(column_name)
+          "strftime('%m', #{column_name})"
+        end
+        
+        def year_sql(column_name)
+          "strftime('%Y', #{column_name})"
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::ConnectionAdapters::SQLiteAdapter.send(:include, Searchgasm::ActiveRecord::ConnectionAdapters::SQLiteAdapter)

data/lib/searchgasm/condition/base.rb

@@ -7,71 +7,47 @@ module Searchgasm
     class Base
       include Shared::Utilities
       
-      attr_accessor :column, :klass
-      class_inheritable_accessor :ignore_meaningless, :type_cast_sql_type
-      self.ignore_meaningless = true
+      attr_accessor :column, :column_for_type_cast, :column_sql, :klass
+      class_inheritable_accessor :handle_array_value, :ignore_meaningless_value, :value_type
+      self.ignore_meaningless_value = true
     
       class << self
-        # Name of the condition inferred from the class name
-        def condition_name
-          name.split("::").last.gsub(/Condition$/, "").underscore
+        # Name of the condition type inferred from the class name
+        def condition_type_name
+          name.split("::").last.underscore
         end
         
-        # I pass you a column you tell me what to call the condition. If you don't want to use this condition for the column
-        # just return nil
-        def name_for_column(column)
-          "#{column.name}_#{condition_name}"
+        def handle_array_value?
+          handle_array_value == true
         end
         
-        # Alias methods for the column condition.
-        def aliases_for_column(column)
-          []
-        end
-        
-        def ignore_meaningless? # :nodoc:
-          ignore_meaningless == true
-        end
-        
-        # Sane as name_for_column but for the class as a whole. For example the tree methods apply to the class as a whole and not
-        # specific columns. Any condition that applies to columns should probably return nil here.
-        def name_for_klass(klass)
-          nil
+        def ignore_meaningless_value? # :nodoc:
+          ignore_meaningless_value == true
         end
         
-        # Alias methods for the klass condition
-        def aliases_for_klass(klass)
+        # Determines what to call the condition for the model
+        #
+        # Searchgasm tries to create conditions on each model. Before it does this it passes the model to this method to see what to call the condition. If the condition type doesnt want to create a condition on
+        # a model it will just return nil and Searchgasm will skip over it.
+        def condition_names_for_model
           []
         end
         
-        # A utility method for using in name_for_column. Determines if a column contains a date.
-        def date_column?(column)
-          [:datetime, :date, :timestamp].include?(column.type)
-        end
-        
-        # A utility method for using in name_for_column. Determines if a column contains a date and a time.
-        def datetime_column?(column)
-          [:datetime, :timestamp, :time, :date].include?(column.type)
-        end
-        
-        # A utility method for using in name_for_column. For example the keywords condition only applied to string columns, the great than condition doesnt.
-        def string_column?(column)
-          [:string, :text].include?(column.type)
-        end
-
-        # A utility method for using in name_for_column. For example you wouldn't want a string column to use the greater thann condition, but you would for an integer column.
-        def comparable_column?(column)
-          [:integer, :float, :decimal, :datetime, :timestamp, :time, :date].include?(column.type)
-        end
-        
-        # A utility method for using in name_for_column. Determines if a column contains a time.
-        def time_column?(column)
-          [:datetime, :timestamp, :time].include?(column.type)
+        # Same as condition_name_for_model, but for a model's column obj
+        def condition_names_for_column
+          [condition_type_name]
         end
       end
     
-      def initialize(klass, column = nil)          
+      def initialize(klass, column_obj = nil, column_type = nil, column_sql = nil)
         self.klass = klass
-        self.column = column.is_a?(String) ? klass.columns_hash[column] : column
+
+        if column_obj
+          self.column = column_obj.class < ::ActiveRecord::ConnectionAdapters::Column ? column_obj : klass.columns_hash[column_obj.to_s]
+          column_type ||= column.type
+          self.column_for_type_cast = column.class.new(column.name, column.default.to_s, self.class.value_type.to_s || column_type.to_s, column.null)
+          self.column_sql = column_sql || "#{klass.connection.quote_table_name(klass.table_name)}.#{klass.connection.quote_column_name(column.name)}"
+        end
       end
     
       # Allows nils to be meaninful values
@@ -84,63 +60,60 @@ module Searchgasm
         @explicitly_set_value == true
       end
       
-      # A convenience method for the name of the method for that specific column or klass
-      def name
-        column ? self.class.name_for_column(column) : self.class.name_for_klass(klass)
-      end
-      
-      # A convenience method for the name of this condition
-      def condition_name
-        self.class.condition_name
-      end
-    
-      # Quotes a column name properly for sql.
-      def quote_column_name(column_name)
-        klass.connection.quote_column_name(column_name)
-      end
-      
-      # A convenience method for using when writing your sql in to_conditions. This is the proper way to use a column name in a query for most databases
-      def quoted_column_name
-        quote_column_name(column.name)
-      end
-      
-      # Quotes a table name properly for sql
-      def quote_table_name(table_name)
-        klass.connection.quote_table_name(table_name)
-      end
-      
-      # A convenience method for using when writing your sql in to_conditions. This is the proper way to use a table name in a query for most databases
-      def quoted_table_name
-        quote_table_name(klass.table_name)
+      def meaningless_value?
+        !explicitly_set_value? || (self.class.ignore_meaningless_value? && meaningless?(@value))
       end
       
       # You should refrain from overwriting this method, it performs various tasks before callign your to_conditions method, allowing you to keep to_conditions simple.
       def sanitize(alt_value = nil) # :nodoc:
-        return unless explicitly_set_value?
+        return if meaningless_value?
         v = alt_value || value
-        if v.is_a?(Array) && !["equals", "does_not_equal"].include?(condition_name)
+        if v.is_a?(Array) && !self.class.handle_array_value?
           merge_conditions(*v.collect { |i| sanitize(i) })
         else
-          v = v.utc if column && [:time, :timestamp, :datetime].include?(column.type) && klass.time_zone_aware_attributes && !klass.skip_time_zone_conversion_for_attributes.include?(column.name.to_sym)
+          v = v.utc if column && v.respond_to?(:utc) && [:time, :timestamp, :datetime].include?(column.type) && klass.time_zone_aware_attributes && !klass.skip_time_zone_conversion_for_attributes.include?(column.name.to_sym)
           to_conditions(v)
         end
       end
-    
+      
       # The value for the condition
       def value
-        @value.is_a?(String) ? column_for_type_cast.type_cast(@value) : @value
+        return @casted_value if @casted_value
+        
+        if !column_for_type_cast || meaningless_value?
+          @casted_value = @value
+        else
+          @casted_value = @value.is_a?(String) ? column_for_type_cast.type_cast(@value) : @value
+        end
       end
     
       # Sets the value for the condition
       def value=(v)
-        return if self.class.ignore_meaningless? && meaningless?(v)
         self.explicitly_set_value = true
+        @casted_value = nil
         @value = v
       end
       
       private
-        def column_for_type_cast
-          @column_for_type_cast ||= self.class.type_cast_sql_type ? self.column.class.new(column.name, column.default.to_s, self.class.type_cast_sql_type.to_s, column.null) : column
+        def meaningless?(v)
+          return false if v == false
+          v.blank?
+        end
+
+        def meaningful?(v)
+          !meaningless?(v)
+        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 quoted_table_name
+          quote_table_name(klass.table_name)
         end
     end
   end

data/lib/searchgasm/condition/begins_with.rb

@@ -2,18 +2,13 @@ module Searchgasm
   module Condition
     class BeginsWith < Base
       class << self
-        def name_for_column(column)
-          return unless string_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          ["#{column.name}_bw", "#{column.name}_sw", "#{column.name}_starts_with", "#{column.name}_start"]
+        def condition_names_for_column
+          super + ["bw", "sw", "starts_with", "start"]
         end
       end
       
       def to_conditions(value)
-        ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "#{value}%"]
+        ["#{column_sql} LIKE ?", "#{value}%"]
       end
     end
   end

data/lib/searchgasm/condition/blank.rb

@@ -1,20 +1,20 @@
 module Searchgasm
   module Condition
     class Blank < Base
-      self.type_cast_sql_type = "boolean"
+      self.value_type = :boolean
       
       class << self
-        def aliases_for_column(column)
-          ["#{column.name}_is_blank"]
+        def condition_names_for_column
+          super + ["is_blank"]
         end
       end
       
       def to_conditions(value)
         # Some databases handle null values differently, let AR handle this
         if value == true
-          "#{quoted_table_name}.#{quoted_column_name} is NULL or #{quoted_table_name}.#{quoted_column_name} = ''"
+          "#{column_sql} is NULL or #{column_sql} = ''"
         elsif value == false
-          "#{quoted_table_name}.#{quoted_column_name} is NOT NULL and #{quoted_table_name}.#{quoted_column_name} != ''"
+          "#{column_sql} is NOT NULL and #{column_sql} != ''"
         end
       end
     end

data/lib/searchgasm/condition/ends_with.rb

@@ -2,18 +2,13 @@ module Searchgasm
   module Condition
     class EndsWith < Base
       class << self
-        def name_for_column(column)
-          return unless string_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          ["#{column.name}_ew", "#{column.name}_ends", "#{column.name}_end"]
+        def condition_names_for_column
+          super + ["ew", "ends", "end"]
         end
       end
       
       def to_conditions(value)
-        ["#{quoted_table_name}.#{quoted_column_name} LIKE ?", "%#{value}"]
+        ["#{column_sql} LIKE ?", "%#{value}"]
       end
     end
   end

data/lib/searchgasm/condition/equals.rb

@@ -1,11 +1,12 @@
 module Searchgasm
   module Condition
     class Equals < Base
-      self.ignore_meaningless = false
+      self.handle_array_value = true
+      self.ignore_meaningless_value = false
       
       class << self
-        def aliases_for_column(column)
-          ["#{column.name}", "#{column.name}_is"]
+        def condition_names_for_column
+          super + ["", "is"]
         end
       end
       

data/lib/searchgasm/condition/greater_than.rb

@@ -2,24 +2,13 @@ module Searchgasm
   module Condition
     class GreaterThan < Base
       class << self
-        def name_for_column(column)
-          return unless comparable_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          column_names = [column.name]
-          column_names << column.name.gsub(/_(at|on)$/, "") if datetime_column?(column) && column.name =~ /_(at|on)$/
-          
-          aliases = []
-          column_names.each { |column_name| aliases += ["#{column_name}_gt", "#{column_name}_after"] }
-          aliases << "#{column_names.last}_greater_than" if column_names.size > 1
-          aliases
+        def condition_names_for_column
+          super + ["gt", "after"]
         end
       end
       
       def to_conditions(value)
-        ["#{quoted_table_name}.#{quoted_column_name} > ?", value]
+        ["#{column_sql} > ?", value]
       end
     end
   end

data/lib/searchgasm/condition/greater_than_or_equal_to.rb

@@ -2,24 +2,13 @@ module Searchgasm
   module Condition
     class GreaterThanOrEqualTo < Base
       class << self
-        def name_for_column(column)
-          return unless comparable_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          column_names = [column.name]
-          column_names << column.name.gsub(/_(at|on)$/, "") if datetime_column?(column) && column.name =~ /_(at|on)$/
-          
-          aliases = []
-          column_names.each { |column_name| aliases += ["#{column_name}_gte", "#{column_name}_at_least"] }
-          aliases << "#{column_names.last}_greater_than_or_equal_to" if column_names.size > 1
-          aliases
+        def condition_names_for_column
+          super + ["gte", "at_least", "least"]
         end
       end
       
       def to_conditions(value)
-        ["#{quoted_table_name}.#{quoted_column_name} >= ?", value]
+        ["#{column_sql} >= ?", value]
       end
     end
   end

data/lib/searchgasm/condition/keywords.rb

@@ -4,13 +4,8 @@ module Searchgasm
       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        
       
       class << self
-        def name_for_column(column)
-          return unless string_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          ["#{column.name}_kwords", "#{column.name}_kw"]
+        def condition_names_for_column
+          super + ["kwords", "kw"]
         end
       end
       
@@ -22,7 +17,7 @@ module Searchgasm
         return if search_parts.blank?
         
         search_parts.each do |search_part|
-          strs << "#{quoted_table_name}.#{quoted_column_name} LIKE ?"
+          strs << "#{column_sql} LIKE ?"
           subs << "%#{search_part}%"
         end
         

data/lib/searchgasm/condition/less_than.rb

@@ -2,24 +2,13 @@ module Searchgasm
   module Condition
     class LessThan < Base
       class << self
-        def name_for_column(column)
-          return unless comparable_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          column_names = [column.name]
-          column_names << column.name.gsub(/_(at|on)$/, "") if datetime_column?(column) && column.name =~ /_(at|on)$/
-          
-          aliases = []
-          column_names.each { |column_name| aliases += ["#{column_name}_lt", "#{column_name}_before"] }
-          aliases << "#{column_names.last}_less_than" if column_names.size > 1
-          aliases
+        def condition_names_for_column
+          super + ["lt", "before"]
         end
       end
       
       def to_conditions(value)
-        ["#{quoted_table_name}.#{quoted_column_name} < ?", value]
+        ["#{column_sql} < ?", value]
       end
     end
   end

data/lib/searchgasm/condition/less_than_or_equal_to.rb

@@ -2,24 +2,13 @@ module Searchgasm
   module Condition
     class LessThanOrEqualTo < Base
       class << self
-        def name_for_column(column)
-          return unless comparable_column?(column)
-          super
-        end
-        
-        def aliases_for_column(column)
-          column_names = [column.name]
-          column_names << column.name.gsub(/_(at|on)$/, "") if datetime_column?(column) && column.name =~ /_(at|on)$/
-          
-          aliases = []
-          column_names.each { |column_name| aliases += ["#{column_name}_lte", "#{column_name}_at_most"] }
-          aliases << "#{column_names.last}_less_than_or_equal_to" if column_names.size > 1
-          aliases
+        def condition_names_for_column
+          super + ["lte", "at_most", "most"]
         end
       end
       
       def to_conditions(value)
-        ["#{quoted_table_name}.#{quoted_column_name} <= ?", value]
+        ["#{column_sql} <= ?", value]
       end
     end
   end

data/lib/searchgasm/condition/like.rb

@@ -0,0 +1,15 @@
+module Searchgasm
+  module Condition
+    class Like < Base
+      class << self
+        def condition_names_for_column
+          super + ["contains", "has"]
+        end
+      end
+      
+      def to_conditions(value)
+        ["#{column_sql} LIKE ?", "%#{value}%"]
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/nil.rb

@@ -1,19 +1,19 @@
 module Searchgasm
   module Condition
     class Nil < Base
-      self.type_cast_sql_type = "boolean"
+      self.value_type = :boolean
       
       class << self
-        def aliases_for_column(column)
-          ["#{column.name}_is_nil", "#{column.name}_is_null", "#{column.name}_null"]
+        def condition_names_for_column
+          super + ["is_nil", "is_null", "null"]
         end
       end
       
       def to_conditions(value)
         if value == true
-          "#{quoted_table_name}.#{quoted_column_name} is NULL"
+          "#{column_sql} is NULL"
         elsif value == false
-          "#{quoted_table_name}.#{quoted_column_name} is NOT NULL"
+          "#{column_sql} is NOT NULL"
         end
       end
     end

data/lib/searchgasm/condition/not_begin_with.rb

@@ -0,0 +1,17 @@
+module Searchgasm
+  module Condition
+    class NotBeginWith < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_bw", "not_sw", "not_start_with", "not_start", "beginning_is_not", "beginning_not"]
+        end
+      end
+      
+      def to_conditions(value)
+        begin_with = BeginWith.new
+        begin_with.value = value
+        being_with.to_conditions.gsub(" LIKE ", " NOT LIKE ")
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/not_end_with.rb

@@ -0,0 +1,17 @@
+module Searchgasm
+  module Condition
+    class NotEndWith < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_ew", "not_end", "end_is_not", "end_not"]
+        end
+      end
+      
+      def to_conditions(value)
+        ends_with = EndsWith.new
+        ends_with.value = value
+        ends_with.to_conditions.gsub(" LIKE ", " NOT LIKE ")
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/{does_not_equal.rb → not_equal.rb}

@@ -1,11 +1,12 @@
 module Searchgasm
   module Condition
-    class DoesNotEqual < Base
-      self.ignore_meaningless = false
+    class NotEqual < Base
+      self.handle_array_value = true
+      self.ignore_meaningless_value = false
       
       class << self
-        def aliases_for_column(column)
-          ["#{column.name}_is_not", "#{column.name}_not"]
+        def condition_names_for_column
+          super + ["does_not_equal", "not_equal", "is_not", "not"]
         end
       end
       

data/lib/searchgasm/condition/not_have_keywords.rb

@@ -0,0 +1,17 @@
+module Searchgasm
+  module Condition
+    class NotHaveKeywords < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_have_keywords", "not_keywords", "not_have_kw", "not_kw", "not_have_kwwords", "not_kwwords"]
+        end
+      end
+      
+      def to_conditions(value)
+        keywords = Keywords.new
+        keywords.value = value
+        keywords.to_conditions.gsub(" LIKE ", " NOT LIKE ")
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/not_like.rb

@@ -0,0 +1,17 @@
+module Searchgasm
+  module Condition
+    class NotLike < Base
+      class << self
+        def condition_names_for_column
+          super + ["not_contain", "not_have"]
+        end
+      end
+      
+      def to_conditions(value)
+        like = Like.new
+        like.value = value
+        like.to_conditions.gsub(" LIKE ", " NOT LIKE ")
+      end
+    end
+  end
+end

data/lib/searchgasm/condition/tree.rb

@@ -2,13 +2,12 @@ module Searchgasm
   module Condition
     class Tree < Base # :nodoc:
       class << self
-        def name_for_column(column)
-          nil
+        def condition_names_for_column
+          []
         end
         
-        def name_for_klass(klass)
-          return unless klass.reflect_on_association(:parent) && klass.reflect_on_association(:children)
-          condition_name
+        def condition_names_for_model(model)
+          [condition_type_name]
         end
       end
     end