searchlogic 2.4.32 → 2.5.19

data/lib/searchlogic/named_scopes/{conditions.rb → column_conditions.rb}

@@ -8,7 +8,7 @@ module Searchlogic
     # Notice the constants in this class, they define which conditions Searchlogic provides.
     #
     # See the README for a more detailed explanation.
-    module Conditions
+    module ColumnConditions
       COMPARISON_CONDITIONS = {
         :equals => [:is, :eq],
         :does_not_equal => [:not_equal_to, :is_not, :not, :ne],
@@ -54,14 +54,19 @@ module Searchlogic
 
       # Is the name of the method a valid condition that can be dynamically created?
       def condition?(name)
-        local_condition?(name)
+        super || column_condition?(name)
+      end
+
+      # We want to return true for any conditions that can be called, and while we're at it. We might as well
+      # create the condition so we don't have to do it again.
+      def respond_to_missing?(*args)
+        super || (self != ::ActiveRecord::Base && !self.abstract_class? && !create_condition(args.first).blank?)
       end
 
       private
-        def local_condition?(name)
+        def column_condition?(name)
           return false if name.blank?
-          scope_names = scopes.keys.reject { |k| k == :scoped }
-          scope_names.include?(name.to_sym) || !condition_details(name).nil? || boolean_condition?(name)
+          !condition_details(name).nil? || boolean_condition?(name)
         end
 
         def boolean_condition?(name)
@@ -70,13 +75,8 @@ module Searchlogic
         end
 
         def method_missing(name, *args, &block)
-          if details = condition_details(name)
-            create_condition(details[:column], details[:condition], args)
-            send(name, *args)
-          elsif boolean_condition?(name)
-            column = name.to_s.gsub(/^not_/, "")
-            named_scope name, :conditions => {column => (name.to_s =~ /^not_/).nil?}
-            send(name)
+          if create_condition(name)
+            send(name, *args, &block)
           else
             super
           end
@@ -91,11 +91,21 @@ module Searchlogic
           end
         end
 
-        def create_condition(column_name, condition, args)
-          if PRIMARY_CONDITIONS.include?(condition.to_sym)
-            create_primary_condition(column_name, condition)
-          elsif ALIAS_CONDITIONS.include?(condition.to_sym)
-            create_alias_condition(column_name, condition, args)
+        def create_condition(name)
+          @conditions_already_tried ||= []
+          return nil if @conditions_already_tried.include?(name.to_s)
+          @conditions_already_tried << name.to_s
+
+          if details = condition_details(name)
+            if PRIMARY_CONDITIONS.include?(details[:condition].to_sym)
+              create_primary_condition(details[:column], details[:condition])
+            elsif ALIAS_CONDITIONS.include?(details[:condition].to_sym)
+              create_alias_condition(details[:column], details[:condition])
+            end
+
+          elsif boolean_condition?(name)
+            column = name.to_s.gsub(/^not_/, "")
+            named_scope name, :conditions => {column => (name.to_s =~ /^not_/).nil?}
           end
         end
 
@@ -103,11 +113,11 @@ module Searchlogic
           column = columns_hash[column_name.to_s]
           column_type = column.type
           skip_conversion = skip_time_zone_conversion_for_attributes.include?(column.name.to_sym)
-          match_keyword = ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+          match_keyword = self.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
 
           scope_options = case condition.to_s
           when /^equals/
-            scope_options(condition, column, lambda { |a| attribute_condition("#{table_name}.#{column.name}", a) }, :skip_conversion => skip_conversion)
+            scope_options(condition, column, "#{table_name}.#{column.name} = ?", :skip_conversion => skip_conversion)
           when /^does_not_equal/
             scope_options(condition, column, "#{table_name}.#{column.name} != ?", :skip_conversion => skip_conversion)
           when /^less_than_or_equal_to/
@@ -149,11 +159,13 @@ module Searchlogic
         # Kepp in mind that the lambdas get cached in a method, so you want to keep the contents of the lambdas as
         # fast as possible, which is why I didn't do the case statement inside of the lambda.
         def scope_options(condition, column, sql, options = {})
+          equals = !(condition.to_s =~ /^equals/).nil?
+          does_not_equal = !(condition.to_s =~ /^does_not_equal/).nil?
+
           case condition.to_s
           when /_(any|all)$/
             any = $1 == "any"
             join_word = any ? " OR " : " AND "
-            equals = condition.to_s =~ /^equals_/
             searchlogic_lambda(column.type, :skip_conversion => options[:skip_conversion]) { |*values|
               unless values.empty?
                 if equals && any
@@ -172,9 +184,9 @@ module Searchlogic
                   values.flatten!
                   values.collect! { |value| value_with_modifier(value, options[:value_modifier]) }
 
-                  scope_sql = values.collect { |value| sql.is_a?(Proc) ? sql.call(value) : sql }.join(join_word)
+                  scope_sql = values.collect { |value| sql }.join(join_word)
 
-                  {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
+                  {:conditions => [scope_sql, *values]}
                 end
               else
                 {}
@@ -184,9 +196,15 @@ module Searchlogic
             searchlogic_lambda(column.type, :skip_conversion => options[:skip_conversion]) { |*values|
               values.collect! { |value| value_with_modifier(value, options[:value_modifier]) }
 
-              scope_sql = sql.is_a?(Proc) ? sql.call(*values) : sql
+              new_sql = if does_not_equal && values == [nil]
+                sql.gsub('!=', 'IS NOT')
+              elsif equals && values == [nil]
+                sql.gsub('=', 'IS')
+              else
+                sql
+              end
 
-              {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
+              {:conditions => [new_sql, *values]}
             }
           end
         end
@@ -204,12 +222,13 @@ module Searchlogic
           end
         end
 
-        def create_alias_condition(column_name, condition, args)
+        def create_alias_condition(column_name, condition)
           primary_condition = primary_condition(condition)
           alias_name = "#{column_name}_#{condition}"
           primary_name = "#{column_name}_#{primary_condition}"
-          send(primary_name, *args) # go back to method_missing and make sure we create the method
-          (class << self; self; end).class_eval { alias_method alias_name, primary_name }
+          if respond_to?(primary_name)
+            (class << self; self; end).class_eval { alias_method alias_name, primary_name }
+          end
         end
 
         # Returns the primary condition for the given alias. Ex:
@@ -238,4 +257,4 @@ module Searchlogic
         end
     end
   end
-end
+end

data/lib/searchlogic/named_scopes/or_conditions.rb

@@ -5,30 +5,30 @@ module Searchlogic
     module OrConditions
       class NoConditionSpecifiedError < StandardError; end
       class UnknownConditionError < StandardError; end
-      
+
       def condition?(name) # :nodoc:
         super || or_condition?(name)
       end
-      
+
       def named_scope_options(name) # :nodoc:
         super || super(or_conditions(name).try(:join, "_or_"))
       end
-      
+
       private
         def or_condition?(name)
           !or_conditions(name).nil?
         end
-        
-        def method_missing(name, *args, &block)
+
+        def create_condition(name)
           if conditions = or_conditions(name)
-            create_or_condition(conditions, args)
-            (class << self; self; end).class_eval { alias_method name, conditions.join("_or_") } if !respond_to?(name)
-            send(name, *args)
+            create_or_condition(conditions)
+            alias_name = conditions.join("_or_")
+            (class << self; self; end).class_eval { alias_method name, conditions.join("_or_") } if name != alias_name
           else
             super
           end
         end
-        
+
         def or_conditions(name)
           # First determine if we should even work on the name, we want to be as quick as possible
           # with this.
@@ -41,7 +41,7 @@ module Searchlogic
             end
           end
         end
-        
+
         def split_or_condition(name)
           parts = name.to_s.split("_or_")
           new_parts = []
@@ -54,7 +54,7 @@ module Searchlogic
           end
           new_parts
         end
-        
+
         # The purpose of this method is to convert the method name parts into actual condition names.
         #
         # Example:
@@ -81,7 +81,7 @@ module Searchlogic
               path = full_association_path(part, last_condition, association_details[:association])
               conditions << "#{path[:path].join("_").to_sym}_#{path[:column]}_#{path[:condition]}"
               last_condition = path[:condition] || nil
-            elsif local_condition?(part)
+            elsif column_condition?(part)
               # We are a custom scope
               conditions << part
             elsif column_names.include?(part)
@@ -90,34 +90,34 @@ module Searchlogic
                 raise NoConditionSpecifiedError.new("The '#{part}' column doesn't know which condition to use, if you use an exact column " +
                   "name you need to specify a condition sometime after (ex: id_or_created_at_lt), where id would use the 'lt' condition.")
               end
-              
+
               conditions << "#{part}_#{last_condition}"
             else
               raise UnknownConditionError.new("The condition '#{part}' is not a valid condition, we could not find any scopes that match this.")
             end
           end
-          
+
           conditions.reverse
         end
 
         def full_association_path(part, last_condition, given_assoc)
-            path = [given_assoc.name]
-            part.sub!(/^#{given_assoc.name}_/, "")
-            klass = self
-            while klass = klass.send(:reflect_on_association, given_assoc.name)
-              klass = klass.klass
-              if details = klass.send(:association_condition_details, part, last_condition)
-                path << details[:association]
-                part = details[:condition]
-                given_assoc = details[:association]
-              elsif details = klass.send(:condition_details, part)
-                return { :path => path, :column => details[:column], :condition => details[:condition] }
-              end
+          path = [given_assoc.name]
+          part.sub!(/^#{given_assoc.name}_/, "")
+          klass = self
+          while klass = klass.send(:reflect_on_association, given_assoc.name)
+            klass = klass.klass
+            if details = klass.send(:association_condition_details, part, last_condition)
+              path << details[:association].name
+              part = details[:condition]
+              given_assoc = details[:association]
+            elsif details = klass.send(:condition_details, part)
+              return { :path => path, :column => details[:column], :condition => details[:condition] }
             end
-            { :path => path, :column => part, :condition => last_condition }
+          end
+          {:path => path, :column => part, :condition => last_condition}
         end
-        
-        def create_or_condition(scopes, args)
+
+        def create_or_condition(scopes)
           scopes_options = scopes.collect { |scope, *args| send(scope, *args).proxy_options }
           # We're using first scope to determine column's type
           scope = named_scope_options(scopes.first)
@@ -126,15 +126,43 @@ module Searchlogic
             merge_scopes_with_or(scopes.collect { |scope| clone.send(scope, *args) })
           }
         end
-        
+
         def merge_scopes_with_or(scopes)
-          scopes_options = scopes.collect { |scope| scope.scope(:find) }
-          conditions = scopes_options.reject { |o| o[:conditions].nil? }.collect { |o| sanitize_sql(o[:conditions]) }
-          scope = scopes_options.inject(scoped({})) { |current_scope, options| current_scope.scoped(options) }
-          options = {}
-          in_searchlogic_delegation { options = scope.scope(:find) }
-          options.delete(:readonly) unless scopes.any? { |scope| scope.proxy_options.key?(:readonly) }
-          options.merge(:conditions => "(" + conditions.join(") OR (") + ")")
+          options = scopes_options(scopes)
+          merged_options = merge_options(options)
+          merged_options.delete(:readonly)
+          if !merged_options[:joins].blank?
+            merged_options[:joins] = convert_joins_to_optional(merged_options[:joins])
+          else
+            merged_options.delete(:joins)
+          end
+          conditions = normalized_conditions(options)
+          if conditions.any?
+            merged_options[:conditions] = "(" + conditions.join(") OR (") + ")"
+          end
+          merged_options
+        end
+
+        def scopes_options(scopes)
+          scopes.collect { |scope| with_exclusive_scope { scope.scope(:find) } }
+        end
+
+        def convert_joins_to_optional(joins)
+          joins ||= []
+
+          (joins || []).collect { |join| join.gsub(/INNER JOIN/, 'LEFT OUTER JOIN') }
+        end
+
+        def merge_options(options)
+          with_exclusive_scope do
+            options.inject(scoped({:joins => "", :conditions => ""})) do |current_scope, option|
+              current_scope.scoped(option)
+            end.scope(:find)
+          end
+        end
+
+        def normalized_conditions(options)
+          options.collect { |option| option[:conditions] && sanitize_sql(option[:conditions]) }.compact
         end
     end
   end

data/lib/searchlogic/named_scopes/ordering.rb

@@ -10,35 +10,34 @@ module Searchlogic
       def condition?(name) # :nodoc:
         super || ordering_condition?(name)
       end
-      
+
       private
         def ordering_condition?(name) # :nodoc:
           !ordering_condition_details(name).nil?
         end
-        
-        def method_missing(name, *args, &block)
+
+        def create_condition(name)
           if name == :order
-            named_scope name, lambda { |scope_name|
-              return {} if !condition?(scope_name)
-              send(scope_name).proxy_options
+            alias_scope name, lambda { |scope_name|
+              return scoped({}) if !condition?(scope_name)
+              send(scope_name)
             }
-            send(name, *args)
           elsif details = ordering_condition_details(name)
             create_ordering_conditions(details[:column])
-            send(name, *args)
           else
             super
           end
         end
-        
+
         def ordering_condition_details(name)
           if name.to_s =~ /^(ascend|descend)_by_(#{column_names.join("|")})$/
             {:order_as => $1, :column => $2}
           elsif name.to_s =~ /^order$/
             {}
           end
+        rescue ::ActiveRecord::StatementInvalid
         end
-        
+
         def create_ordering_conditions(column)
           named_scope("ascend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} ASC"})
           named_scope("descend_by_#{column}".to_sym, {:order => "#{table_name}.#{column} DESC"})

data/lib/searchlogic/rails_helpers.rb

@@ -69,7 +69,11 @@ module Searchlogic
     def fields_for(*args, &block)
       if search_obj = args.find { |arg| arg.is_a?(Searchlogic::Search) }
         args.unshift(:search) if args.first == search_obj
-        concat(content_tag("div", hidden_field_tag("#{args.first}[order]", search_obj.order)))
+        options = args.extract_options!
+        if !options[:skip_order_field]
+          concat(content_tag("div", hidden_field_tag("#{args.first}[order]", search_obj.order), :style => "display: inline"))
+        end
+        args << options
         super
       else
         super

data/lib/searchlogic/search/conditions.rb

@@ -7,7 +7,7 @@ module Searchlogic
       end
 
       def compact_conditions
-        conditions.select { |k,v| !v.blank? }
+        Hash[conditions.select { |k,v| !v.blank? }]
       end
 
       # Accepts a hash of conditions.
@@ -31,13 +31,13 @@ module Searchlogic
         end
         self
       end
-      
+
       private
         # This is here as a hook to allow people to modify the order in which the conditions are called, for whatever reason.
         def conditions_array
           @conditions.to_a
         end
-        
+
         def write_condition(name, value)
           @conditions[name] = value
         end
@@ -49,7 +49,7 @@ module Searchlogic
         def mass_conditions
           @mass_conditions ||= {}
         end
-        
+
         def ignore_value?(value)
           (value.is_a?(String) && value.blank?) || (value.is_a?(Array) && value.empty?)
         end

data/lib/searchlogic/search/method_missing.rb

@@ -1,7 +1,7 @@
 module Searchlogic
   class Search
     module MethodMissing
-      def respond_to?(*args)
+      def respond_to_missing?(*args)
         super || scope?(normalize_scope_name(args.first))
       rescue Searchlogic::NamedScopes::OrConditions::UnknownConditionError
         false
@@ -89,7 +89,7 @@ module Searchlogic
         def type_cast(value, type, options = {})
           case value
           when Array
-            value.collect { |v| type_cast(v, type) }
+            value.collect { |v| type_cast(v, type) }.uniq
           when Range
             Range.new(type_cast(value.first, type), type_cast(value.last, type))
           else
@@ -101,17 +101,12 @@ module Searchlogic
 
             if Time.zone && casted_value.is_a?(Time)
               if value.is_a?(String)
-                if options[:skip_conversion]
-                  casted_value.utc
-                else
-                  (casted_value + (Time.zone.utc_offset * -1)).in_time_zone
-                end
+                # if its a string, we should assume the user means the local time
+                # we need to update the object to include the proper time zone without changing
+                # the time
+                (casted_value + (Time.zone.utc_offset * -1)).in_time_zone(Time.zone)
               else
-                if options[:skip_conversion]
-                  casted_value.utc
-                else
-                  casted_value.in_time_zone
-                end
+                casted_value.in_time_zone
               end
             else
               casted_value

data/lib/searchlogic/search/ordering.rb

@@ -3,7 +3,11 @@ module Searchlogic
     module Ordering
       # Returns the column we are currently ordering by
       def ordering_by
-        order && order.to_s.gsub(/^(ascend|descend)_by_/, '')
+        @ordering_by ||= order && order.to_s.match(/^(ascend|descend)_by_(.*)$/).try(:[], 2)
+      end
+
+      def ordering_direction
+        @ordering_direction ||= order && order.to_s.match(/^(ascend|descend)_by_/).try(:[], 1)
       end
     end
   end

data/lib/searchlogic/search/to_yaml.rb

@@ -7,7 +7,7 @@ module Searchlogic
           include InstanceMethods
         end
       end
-      
+
       module InstanceMethods
         def to_yaml( opts = {} )
           YAML::quick_emit( self, opts ) do |out|
@@ -18,7 +18,7 @@ module Searchlogic
             end
           end
         end
-        
+
         def yaml_initialize(taguri, attributes = {})
           self.klass = attributes["class_name"].constantize
           self.current_scope = attributes["current_scope"]

data/lib/searchlogic/version.rb

@@ -0,0 +1,3 @@
+module Searchlogic
+  VERSION = "2.5.19"
+end

data/lib/searchlogic.rb

@@ -1,9 +1,13 @@
+require 'active_support'
+require 'active_record'
+require "searchlogic/version"
 require "searchlogic/core_ext/proc"
 require "searchlogic/core_ext/object"
-require "searchlogic/active_record/association_proxy"
 require "searchlogic/active_record/consistency"
 require "searchlogic/active_record/named_scope_tools"
-require "searchlogic/named_scopes/conditions"
+require "searchlogic/active_record/scope"
+require "searchlogic/named_scopes/base"
+require "searchlogic/named_scopes/column_conditions"
 require "searchlogic/named_scopes/ordering"
 require "searchlogic/named_scopes/association_conditions"
 require "searchlogic/named_scopes/association_ordering"
@@ -24,19 +28,15 @@ Proc.send(:include, Searchlogic::CoreExt::Proc)
 Object.send(:include, Searchlogic::CoreExt::Object)
 
 module ActiveRecord # :nodoc: all
-  module Associations
-    class AssociationProxy
-      include Searchlogic::ActiveRecord::AssociationProxy
-    end
-  end
-
   class Base
     class << self; include Searchlogic::ActiveRecord::Consistency; end
   end
 end
 
+ActiveRecord::Base.extend(Searchlogic::ActiveRecord::Scope)
 ActiveRecord::Base.extend(Searchlogic::ActiveRecord::NamedScopeTools)
-ActiveRecord::Base.extend(Searchlogic::NamedScopes::Conditions)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::Base)
+ActiveRecord::Base.extend(Searchlogic::NamedScopes::ColumnConditions)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::AssociationConditions)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::AssociationOrdering)
 ActiveRecord::Base.extend(Searchlogic::NamedScopes::Ordering)

data/searchlogic.gemspec

@@ -1,99 +1,28 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require File.expand_path('../lib/searchlogic/version', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = %q{searchlogic}
-  s.version = "2.4.32"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ben Johnson of Binary Logic"]
-  s.date = %q{2011-03-07}
+  s.name        = "searchlogic"
+  s.version     = Searchlogic::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ben Johnson"]
+  s.email       = ["bjohnson@binarylogic.com"]
+  s.homepage    = "http://github.com/binarylogic/searchlogic"
+  s.summary     = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive.}
   s.description = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive.}
-  s.email = %q{bjohnson@binarylogic.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.rdoc"
-  ]
-  s.files = [
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION.yml",
-    "init.rb",
-    "lib/searchlogic.rb",
-    "lib/searchlogic/active_record/association_proxy.rb",
-    "lib/searchlogic/active_record/consistency.rb",
-    "lib/searchlogic/active_record/named_scope_tools.rb",
-    "lib/searchlogic/core_ext/object.rb",
-    "lib/searchlogic/core_ext/proc.rb",
-    "lib/searchlogic/named_scopes/alias_scope.rb",
-    "lib/searchlogic/named_scopes/association_conditions.rb",
-    "lib/searchlogic/named_scopes/association_ordering.rb",
-    "lib/searchlogic/named_scopes/conditions.rb",
-    "lib/searchlogic/named_scopes/or_conditions.rb",
-    "lib/searchlogic/named_scopes/ordering.rb",
-    "lib/searchlogic/rails_helpers.rb",
-    "lib/searchlogic/search.rb",
-    "lib/searchlogic/search/base.rb",
-    "lib/searchlogic/search/conditions.rb",
-    "lib/searchlogic/search/date_parts.rb",
-    "lib/searchlogic/search/implementation.rb",
-    "lib/searchlogic/search/method_missing.rb",
-    "lib/searchlogic/search/ordering.rb",
-    "lib/searchlogic/search/scopes.rb",
-    "lib/searchlogic/search/to_yaml.rb",
-    "lib/searchlogic/search/unknown_condition_error.rb",
-    "rails/init.rb",
-    "searchlogic.gemspec",
-    "spec/searchlogic/active_record/association_proxy_spec.rb",
-    "spec/searchlogic/active_record/consistency_spec.rb",
-    "spec/searchlogic/core_ext/object_spec.rb",
-    "spec/searchlogic/core_ext/proc_spec.rb",
-    "spec/searchlogic/named_scopes/alias_scope_spec.rb",
-    "spec/searchlogic/named_scopes/association_conditions_spec.rb",
-    "spec/searchlogic/named_scopes/association_ordering_spec.rb",
-    "spec/searchlogic/named_scopes/conditions_spec.rb",
-    "spec/searchlogic/named_scopes/or_conditions_spec.rb",
-    "spec/searchlogic/named_scopes/ordering_spec.rb",
-    "spec/searchlogic/search_spec.rb",
-    "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/binarylogic/searchlogic}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.2}
-  s.summary = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive.}
-  s.test_files = [
-    "spec/searchlogic/active_record/association_proxy_spec.rb",
-    "spec/searchlogic/active_record/consistency_spec.rb",
-    "spec/searchlogic/core_ext/object_spec.rb",
-    "spec/searchlogic/core_ext/proc_spec.rb",
-    "spec/searchlogic/named_scopes/alias_scope_spec.rb",
-    "spec/searchlogic/named_scopes/association_conditions_spec.rb",
-    "spec/searchlogic/named_scopes/association_ordering_spec.rb",
-    "spec/searchlogic/named_scopes/conditions_spec.rb",
-    "spec/searchlogic/named_scopes/or_conditions_spec.rb",
-    "spec/searchlogic/named_scopes/ordering_spec.rb",
-    "spec/searchlogic/search_spec.rb",
-    "spec/spec_helper.rb"
-  ]
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+  s.add_dependency 'activerecord', '~> 2.3.12'
+  s.add_dependency 'activesupport', '~> 2.3.12'
+  s.add_development_dependency 'rspec', '~> 1.3.1'
+  s.add_development_dependency 'timecop', '~> 0.5.9.1'
+  s.add_development_dependency 'sqlite3', '~> 1.3.8'
+  s.add_development_dependency 'appraisal', '0.4.1'
+  s.add_development_dependency 'pry', '>= 0'
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, ["~> 2.3.11"])
-      s.add_runtime_dependency(%q<activerecord>, ["~> 2.3.11"])
-    else
-      s.add_dependency(%q<activerecord>, ["~> 2.3.11"])
-      s.add_dependency(%q<activerecord>, ["~> 2.3.11"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, ["~> 2.3.11"])
-    s.add_dependency(%q<activerecord>, ["~> 2.3.11"])
-  end
-end
 
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/searchlogic/active_record/association_proxy_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require 'spec_helper'
 
 describe "Searchlogic::ActiveRecord::AssociationProxy" do
   it "should call location conditions" do