searchlogic 1.6.6 → 2.1.0

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

@@ -1,172 +0,0 @@
-module Searchlogic
-  module ActiveRecord
-    module ConnectionAdapters
-      module PostgreSQLAdapter
-        # Datetime functions
-        def microseconds_sql(column_name)
-          "date_part('microseconds', #{column_name})"
-        end
-        
-        def milliseconds_sql(column_name)
-          "date_part('milliseconds', #{column_name})"
-        end
-        
-        def second_sql(column_name)
-          "date_part('second', #{column_name})"
-        end
-        
-        def minute_sql(column_name)
-          "date_part('minute', #{column_name})"
-        end
-        
-        def hour_sql(column_name)
-          "date_part('hour', #{column_name})"
-        end
-        
-        def day_of_week_sql(column_name)
-          "(date_part('dow', #{column_name}) + 1)"
-        end
-        
-        def day_of_month_sql(column_name)
-          "date_part('day', #{column_name})"
-        end
-        
-        def day_of_year_sql(column_name)
-          "date_part('doy', #{column_name})"
-        end
-        
-        def week_sql(column_name)
-          "date_part('week', #{column_name})"
-        end
-        
-        def month_sql(column_name)
-          "date_part('month', #{column_name})"
-        end
-        
-        def year_sql(column_name)
-          "date_part('year', #{column_name})"
-        end
-        
-        # String functions
-        def char_length_sql(column_name)
-          "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 avg_sql(column_name)
-          "AVG(#{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)
-          "to_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)
-          "log(2.0, #{column_name})"
-        end
-        
-        def log10_sql(column_name)
-          "log(10.0, #{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::PostgreSQLAdapter.send(:include, Searchlogic::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)

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

@@ -1,80 +0,0 @@
-module Searchlogic
-  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}) * 1)"
-        end
-        
-        def minute_sql(column_name)
-          "(strftime('%M', #{column_name}) * 1)"
-        end
-        
-        def hour_sql(column_name)
-          "(strftime('%H', #{column_name}) * 1)"
-        end
-        
-        def day_of_week_sql(column_name)
-          "(strftime('%w', #{column_name}) * 1)"
-        end
-        
-        def day_of_month_sql(column_name)
-          "(strftime('%d', #{column_name}) * 1)"
-        end
-        
-        def day_of_year_sql(column_name)
-          "(strftime('%j', #{column_name}) * 1)"
-        end
-        
-        def week_sql(column_name)
-          "(strftime('%W', #{column_name}) * 1)"
-        end
-        
-        def month_sql(column_name)
-          "(strftime('%m', #{column_name}) * 1)"
-        end
-        
-        def year_sql(column_name)
-          "(strftime('%Y', #{column_name}) * 1)"
-        end
-        
-        # Number functions
-        def avg_sql(column_name)
-          "AVG(#{column_name})"
-        end
-        
-        # String functions
-        def lower_sql(column_name)
-          "lower(#{column_name})"
-        end
-        
-        def ltrim_sql(column_name)
-          "ltrim(#{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
-      end
-    end
-  end
-end
-
-::ActiveRecord::ConnectionAdapters::SQLiteAdapter.send(:include, Searchlogic::ActiveRecord::ConnectionAdapters::SQLiteAdapter)

data/lib/searchlogic/condition/base.rb

@@ -1,165 +0,0 @@
-module Searchlogic
-  module Condition # :nodoc:
-    # = Conditions condition
-    #
-    # The base class for creating a condition. Your custom conditions should extend this class.
-    # See Searchlogic::Conditions::Base.register_condition on how to write your own condition.
-    class Base
-      include Shared::Utilities
-      
-      attr_accessor :column, :column_for_type_cast, :column_sql, :column_sql_format, :explicit_any, :klass, :object_name, :table_name
-      class_inheritable_accessor :handle_array_value, :ignore_meaningless_value, :join_arrays_with_or, :value_type
-      self.ignore_meaningless_value = true
-    
-      class << self
-        # Name of the condition type inferred from the class name
-        def condition_type_name
-          name.split("::").last.underscore
-        end
-                
-        def handle_array_value?
-          handle_array_value == true
-        end
-        
-        def ignore_meaningless_value? # :nodoc:
-          ignore_meaningless_value == true
-        end
-        
-        def join_arrays_with_or?
-          join_arrays_with_or == true
-        end
-        
-        # Determines what to call the condition for the model
-        #
-        # Searchlogic 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 Searchlogic will skip over it.
-        def condition_names_for_model
-          []
-        end
-        
-        # 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, options = {})
-        self.klass = klass
-        self.table_name = options[:table_name] || klass.table_name
-        
-        if options[:column]
-          self.column = options[:column].class < ::ActiveRecord::ConnectionAdapters::Column ? options[:column] : klass.columns_hash[options[:column].to_s]
-          
-          if options[:column_for_type_cast]
-            self.column_for_type_cast = options[:column_for_type_cast]
-          else
-            type = (!self.class.value_type.blank? && self.class.value_type.to_s) || (!options[:column_type].blank? && options[:column_type].to_s) || column.sql_type
-            self.column_for_type_cast = column.class.new(column.name, column.default.to_s, type, column.null)
-          end
-          
-          self.column_sql_format = options[:column_sql_format] || "{table}.{column}"
-        end
-      end
-      
-      def explicit_any? # :nodoc:
-        explicit_any == true
-      end
-      
-      # Substitutes string vars with table and column name. Allows us to switch the column and table on the fly and have the condition update appropriately.
-      # The table name could be variable depending on the condition. Take STI and more than one child model is used in the condition, the first gets the parent table name, the rest get aliases.
-      def column_sql
-        column_sql_format.gsub("{table}", quoted_table_name).gsub("{column}", quoted_column_name)
-      end
-    
-      # Allows nils to be meaninful values
-      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 options
-        {:table_name => table_name, :column => column, :column_for_type_cast => column_for_type_cast, :column_sql_format => column_sql_format}
-      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 if value_is_meaningless?
-        v = alt_value || value
-        if v.is_a?(Array) && !self.class.handle_array_value?
-          scope_condition(merge_conditions(*v.collect { |i| sanitize(i) } << {:any => self.class.join_arrays_with_or?}))
-        else
-          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
-        @casted_value ||= type_cast_value(@value)
-      end
-    
-      # Sets the value for the condition
-      def value=(v)
-        self.explicitly_set_value = true
-        @casted_value = nil
-        @value = v
-      end
-      
-      def value_is_meaningless? # :nodoc:
-        meaningless?(@value)
-      end
-      
-      private
-        def like_condition_name
-          @like_condition_name ||= klass.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
-        end
-        
-        def meaningless?(v)
-          case v
-          when Array
-            v.each { |i| return false unless meaningless?(i) }
-            true
-          else
-            !explicitly_set_value? || (self.class.ignore_meaningless_value? && v != false && v.blank?)
-          end
-        end
-
-        def meaningful?(v)
-          !meaningless?(v)
-        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 quote_table_name(table_name)
-          klass.connection.quote_table_name(table_name)
-        end
-        
-        def quoted_table_name
-          quote_table_name(table_name)
-        end
-        
-        def type_cast_value(v)
-          case v
-          when Array
-            v.collect { |i| type_cast_value(i) }.compact
-          else
-            return if meaningless?(v)
-            return v if !column_for_type_cast || !v.is_a?(String)
-            tcv = column_for_type_cast.type_cast(v) 
-            tcv -= Time.zone.utc_offset if tcv.is_a?(Time)
-            tcv
-          end
-        end
-    end
-  end
-end

data/lib/searchlogic/condition/begins_with.rb

@@ -1,17 +0,0 @@
-module Searchlogic
-  module Condition
-    class BeginsWith < Base
-      self.join_arrays_with_or = true
-      
-      class << self
-        def condition_names_for_column
-          super + ["bw", "sw", "starts_with", "start"]
-        end
-      end
-      
-      def to_conditions(value)
-        ["#{column_sql} LIKE ?", "#{value}%"]
-      end
-    end
-  end
-end

data/lib/searchlogic/condition/blank.rb

@@ -1,24 +0,0 @@
-module Searchlogic
-  module Condition
-    class Blank < Base
-      self.value_type = :boolean
-      
-      class << self
-        def condition_names_for_column
-          super + ["is_blank"]
-        end
-      end
-      
-      def to_conditions(value)
-        case column.type
-        when :boolean
-          return "(#{column_sql} IS NULL or #{column_sql} = '' or #{column_sql} = false)" if value == true
-          return "(#{column_sql} IS NOT NULL and #{column_sql} != '' and #{column_sql} != false)" if value == false
-        else
-          return "(#{column_sql} IS NULL or #{column_sql} = '')" if value == true
-          return "(#{column_sql} IS NOT NULL and #{column_sql} != '')" if value == false
-        end
-      end
-    end
-  end
-end