searchlogic 2.4.12 → 2.4.13

data/VERSION.yml

@@ -2,4 +2,4 @@
 :major: 2
 :build: 
 :minor: 4
-:patch: 12
+:patch: 13

data/lib/searchlogic/core_ext/object.rb

@@ -31,9 +31,11 @@ module Searchlogic
       # If you want something else, you need to specify it as I did in the above example. Comments are appreciated
       # on this, if you know of a better solution please let me know. But this is the best I could come up with,
       # without being intrusive and altering default behavior.
-      def searchlogic_lambda(type = :string, &block)
+      def searchlogic_lambda(type = :string, options = {}, &block)
         proc = lambda(&block)
-        proc.searchlogic_arg_type = type
+        proc.searchlogic_options ||= {}
+        proc.searchlogic_options[:type] = type
+        proc.searchlogic_options.merge!(options)
         proc
       end
     end

data/lib/searchlogic/core_ext/proc.rb

@@ -3,7 +3,13 @@ module Searchlogic
     module Proc # :nodoc:
       def self.included(klass)
         klass.class_eval do
-          attr_accessor :searchlogic_arg_type
+          attr_accessor :searchlogic_options
+          
+          def searchlogic_options
+            @searchlogic_options ||= {}
+            @searchlogic_options[:type] ||= :string
+            @searchlogic_options
+          end
         end
       end
     end

data/lib/searchlogic/named_scopes/association_conditions.rb

@@ -71,7 +71,7 @@ module Searchlogic
             options
           else
             proc_args = arity_args(arity)
-            arg_type = (scope_options.respond_to?(:searchlogic_arg_type) && scope_options.searchlogic_arg_type) || :string
+            arg_type = (scope_options.respond_to?(:searchlogic_options) && scope_options.searchlogic_options[:type]) || :string
             
             eval <<-"end_eval"
               searchlogic_lambda(:#{arg_type}) { |#{proc_args.join(",")}|

data/lib/searchlogic/named_scopes/conditions.rb

@@ -108,33 +108,34 @@ module Searchlogic
         
         def create_primary_condition(column, condition)
           column_type = columns_hash[column.to_s].type
+          skip_conversion = skip_time_zone_conversion_for_attributes.include?(columns_hash[column.to_s].name.to_sym)
           match_keyword = ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
           
           scope_options = case condition.to_s
           when /^equals/
-            scope_options(condition, column_type, lambda { |a| attribute_condition("#{table_name}.#{column}", a) })
+            scope_options(condition, column_type, lambda { |a| attribute_condition("#{table_name}.#{column}", a) }, :skip_conversion => skip_conversion)
           when /^does_not_equal/
-            scope_options(condition, column_type, "#{table_name}.#{column} != ?")
+            scope_options(condition, column_type, "#{table_name}.#{column} != ?", :skip_conversion => skip_conversion)
           when /^less_than_or_equal_to/
-            scope_options(condition, column_type, "#{table_name}.#{column} <= ?")
+            scope_options(condition, column_type, "#{table_name}.#{column} <= ?", :skip_conversion => skip_conversion)
           when /^less_than/
-            scope_options(condition, column_type, "#{table_name}.#{column} < ?")
+            scope_options(condition, column_type, "#{table_name}.#{column} < ?", :skip_conversion => skip_conversion)
           when /^greater_than_or_equal_to/
-            scope_options(condition, column_type, "#{table_name}.#{column} >= ?")
+            scope_options(condition, column_type, "#{table_name}.#{column} >= ?", :skip_conversion => skip_conversion)
           when /^greater_than/
-            scope_options(condition, column_type, "#{table_name}.#{column} > ?")
+            scope_options(condition, column_type, "#{table_name}.#{column} > ?", :skip_conversion => skip_conversion)
           when /^like/
-            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :like)
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :like)
           when /^not_like/
-            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :like)
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :like)
           when /^begins_with/
-            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :begins_with)
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :begins_with)
           when /^not_begin_with/
-            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :begins_with)
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :begins_with)
           when /^ends_with/
-            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :ends_with)
+            scope_options(condition, column_type, "#{table_name}.#{column} #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :ends_with)
           when /^not_end_with/
-            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :ends_with)
+            scope_options(condition, column_type, "#{table_name}.#{column} NOT #{match_keyword} ?", :skip_conversion => skip_conversion, :value_modifier => :ends_with)
           when "null"
             {:conditions => "#{table_name}.#{column} IS NULL"}
           when "not_null"
@@ -153,13 +154,13 @@ module Searchlogic
         # This method helps cut down on defining scope options for conditions that allow *_any or *_all conditions.
         # 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_type, sql, value_modifier = nil)
+        def scope_options(condition, column_type, sql, options = {})
           case condition.to_s
           when /_(any|all)$/
-            searchlogic_lambda(column_type) { |*values|
+            searchlogic_lambda(column_type, :skip_conversion => options[:skip_conversion]) { |*values|
               return {} if values.empty?
               values.flatten!
-              values.collect! { |value| value_with_modifier(value, value_modifier) }
+              values.collect! { |value| value_with_modifier(value, options[:value_modifier]) }
               
               join = $1 == "any" ? " OR " : " AND "
               scope_sql = values.collect { |value| sql.is_a?(Proc) ? sql.call(value) : sql }.join(join)
@@ -167,8 +168,8 @@ module Searchlogic
               {:conditions => [scope_sql, *expand_range_bind_variables(values)]}
             }
           else
-            searchlogic_lambda(column_type) { |*values|
-              values.collect! { |value| value_with_modifier(value, value_modifier) }
+            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
               

data/lib/searchlogic/named_scopes/or_conditions.rb

@@ -121,7 +121,7 @@ module Searchlogic
           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)
-          column_type = scope.respond_to?(:searchlogic_arg_type) ? scope.searchlogic_arg_type : :string
+          column_type = scope.respond_to?(:searchlogic_options) ? scope.searchlogic_options[:type] : :string
           named_scope scopes.join("_or_"), searchlogic_lambda(column_type) { |*args|
             merge_scopes_with_or(scopes.collect { |scope| clone.send(scope, *args) })
           }

data/lib/searchlogic/search.rb

@@ -90,7 +90,14 @@ module Searchlogic
         if setter?(name)
           if scope?(scope_name)
             if args.size == 1
-              write_condition(condition_name, type_cast(args.first, cast_type(scope_name)))
+              write_condition(
+                condition_name,
+                type_cast(
+                  args.first,
+                  cast_type(scope_name),
+                  scope_options(scope_name).respond_to?(:searchlogic_options) ? scope_options(scope_name).searchlogic_options : {}
+                )
+              )
             else
               write_condition(condition_name, args)
             end
@@ -169,18 +176,22 @@ module Searchlogic
         klass.scopes.key?(scope_name) || klass.condition?(scope_name)
       end
       
-      def cast_type(name)
+      def scope_options(name)
         klass.send(name, nil) if !klass.respond_to?(name) # We need to set up the named scope if it doesn't exist, so we can get a value for named_scope_options
-        named_scope_options = klass.named_scope_options(name)
+        klass.named_scope_options(name)
+      end
+      
+      def cast_type(name)
+        named_scope_options = scope_options(name)
         arity = klass.named_scope_arity(name)
         if !arity || arity == 0
           :boolean
         else
-          named_scope_options.respond_to?(:searchlogic_arg_type) ? named_scope_options.searchlogic_arg_type : :string
+          named_scope_options.respond_to?(:searchlogic_options) ? named_scope_options.searchlogic_options[:type] : :string
         end
       end
       
-      def type_cast(value, type)
+      def type_cast(value, type, options = {})
         case value
         when Array
           value.collect { |v| type_cast(v, type) }
@@ -195,7 +206,11 @@ module Searchlogic
           
           if Time.zone && casted_value.is_a?(Time)
             if value.is_a?(String)
-              (casted_value + (Time.zone.utc_offset * -1)).in_time_zone
+              if options[:skip_conversion]
+                casted_value.utc
+              else
+                (casted_value + (Time.zone.utc_offset * -1)).in_time_zone
+              end
             else
               casted_value.in_time_zone
             end

data/searchlogic.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{searchlogic}
-  s.version = "2.4.12"
+  s.version = "2.4.13"
 
   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{2010-03-09}
+  s.date = %q{2010-04-04}
   s.description = %q{Searchlogic makes using ActiveRecord named scopes easier and less repetitive.}
   s.email = %q{bjohnson@binarylogic.com}
   s.extra_rdoc_files = [

data/spec/core_ext/object_spec.rb

@@ -1,7 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe "Object" do
-  it "should accept and pass the argument to the searchlogic_arg_type" do
-    searchlogic_lambda(:integer) {}.searchlogic_arg_type.should == :integer
+  it "should accept and pass the argument to the searchlogic_options" do
+    proc = searchlogic_lambda(:integer, :test => :value) {}
+    proc.searchlogic_options[:type].should == :integer
+    proc.searchlogic_options[:test].should == :value
   end
 end

data/spec/core_ext/proc_spec.rb

@@ -1,9 +1,8 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe "Proc" do
-  it "should have a searchlogic_arg_type accessor" do
+  it "should have a searchlogic_options accessor" do
     p = Proc.new {}
-    p.searchlogic_arg_type = :integer
-    p.searchlogic_arg_type.should == :integer
+    p.searchlogic_options[:type] = :integer
   end
 end

data/spec/named_scopes/conditions_spec.rb

@@ -290,17 +290,17 @@ describe "Conditions" do
   context "searchlogic lambda" do
     it "should be a string" do
       User.username_like("test")
-      User.named_scope_options(:username_like).searchlogic_arg_type.should == :string
+      User.named_scope_options(:username_like).searchlogic_options[:type].should == :string
     end
     
     it "should be an integer" do
       User.id_gt(10)
-      User.named_scope_options(:id_gt).searchlogic_arg_type.should == :integer
+      User.named_scope_options(:id_gt).searchlogic_options[:type].should == :integer
     end
     
     it "should be a float" do
       Order.total_gt(10)
-      Order.named_scope_options(:total_gt).searchlogic_arg_type.should == :float
+      Order.named_scope_options(:total_gt).searchlogic_options[:type].should == :float
     end
   end
   

data/spec/search_spec.rb

@@ -290,6 +290,12 @@ describe "Search" do
         search.created_at_after.should == Time.zone.parse("Jan 1, 2009 9:33AM")
       end
       
+      it "should skip time zone conversion for attributes skipped" do
+        search = User.search
+        search.whatever_at_after = "Jan 1, 2009 9:33AM"
+        search.whatever_at_after.should == Time.parse("Jan 1, 2009 9:33AM").utc
+      end
+      
       it "should convert the time to the current zone" do
         search = Order.search
         now = Time.now

data/spec/spec_helper.rb

@@ -42,6 +42,7 @@ ActiveRecord::Schema.define(:version => 1) do
     t.integer :age
     t.boolean :male
     t.string :some_type_id
+    t.datetime :whatever_at
   end
   
   create_table :carts do |t|
@@ -99,6 +100,8 @@ Spec::Runner.configure do |config|
       has_many :orders, :dependent => :destroy
       has_many :orders_big, :class_name => 'Order', :conditions => 'total > 100'
       has_and_belongs_to_many :user_groups
+      
+      self.skip_time_zone_conversion_for_attributes = [:whatever_at]
     end
     
     class Order < ActiveRecord::Base

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 4
-  - 12
-  version: 2.4.12
+  - 13
+  version: 2.4.13
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-09 00:00:00 -08:00
+date: 2010-04-04 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency