merge or conditions creates optional joins

Author: binarylogic

.ruby-version

@@ -0,0 +1 @@
+1.9.3-p448

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    searchlogic (2.5.13)
+    searchlogic (2.5.12)
       activerecord (~> 2.3.12)
       activesupport (~> 2.3.12)
 
@@ -14,15 +14,23 @@ GEM
     appraisal (0.4.1)
       bundler
       rake
-    rake (10.0.4)
+    coderay (1.1.0)
+    method_source (0.8.2)
+    pry (0.9.12.3)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
     rspec (1.3.2)
-    sqlite3 (1.3.7)
+    slop (3.4.7)
+    sqlite3 (1.3.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   appraisal (= 0.4.1)
+  pry
   rspec (~> 1.3.1)
   searchlogic!
   sqlite3

lib/searchlogic.rb

@@ -1,3 +1,4 @@
+require 'active_support'
 require 'active_record'
 require "searchlogic/version"
 require "searchlogic/core_ext/proc"

lib/searchlogic/named_scopes/association_conditions.rb

@@ -62,7 +62,7 @@ def association_condition_options(association, association_condition, poly_class
           raise ArgumentError.new("The #{klass} class does not respond to the #{association_condition} scope") if !klass.respond_to?(association_condition)
           arity = klass.named_scope_arity(association_condition)
 
-          if !arity
+          if !arity || arity == 0
             # The underlying condition doesn't require any parameters, so let's just create a simple
             # named scope that is based on a hash.
             options = {}

lib/searchlogic/named_scopes/or_conditions.rb

@@ -128,13 +128,41 @@ def create_or_condition(scopes)
         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

lib/searchlogic/search/method_missing.rb

@@ -15,15 +15,12 @@ def method_missing(name, *args, &block)
           if setter?(name)
             if scope?(scope_name)
               if args.size == 1
-                options = scope_options(scope_name).respond_to?(:searchlogic_options) ? scope_options(scope_name).searchlogic_options : {}
-                options[:cast_single_val_to_array] = cast_single_val_to_array?(condition_name)
-
                 write_condition(
                   condition_name,
                   type_cast(
                     args.first,
                     cast_type(scope_name),
-                    options
+                    scope_options(scope_name).respond_to?(:searchlogic_options) ? scope_options(scope_name).searchlogic_options : {}
                   )
                 )
               else
@@ -103,24 +100,19 @@ def type_cast(value, type, options = {})
             casted_value = column_for_type_cast.type_cast(value)
 
             if Time.zone && casted_value.is_a?(Time)
-              casted_value = if value.is_a?(String)
+              if value.is_a?(String)
                 # 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
                 casted_value.in_time_zone
               end
+            else
+              casted_value
             end
-
-            options[:cast_single_val_to_array] ? [casted_value] : casted_value
           end
         end
-
-        # For *_equals_any conditions, cast single values to an array, ex: 5 to [5] or 'ben' to ['ben']
-        def cast_single_val_to_array?(condition_name)
-          condition_name =~ /^\w+_equals_any/
-        end
     end
   end
 end

lib/searchlogic/version.rb

@@ -1,3 +1,3 @@
 module Searchlogic
-  VERSION = "2.5.14"
+  VERSION = "2.5.12"
 end

searchlogic-2.5.14.gem

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec', '~> 1.3.1'
   s.add_development_dependency 'sqlite3'
   s.add_development_dependency 'appraisal', '0.4.1'
+  s.add_development_dependency 'pry'
 
 
   s.files         = `git ls-files`.split("\n")

searchlogic.gemspec

@@ -5,58 +5,58 @@
     User.name_or_username_like('Test')
     User.respond_to?(:name_or_username_like).should be_true
   end
-  
+
   it "should match username or name" do
     User.username_or_name_like("ben").proxy_options.should == {:conditions => "(users.username LIKE '%ben%') OR (users.name LIKE '%ben%')"}
   end
-  
+
   it "should use the specified condition" do
     User.username_begins_with_or_name_like("ben").proxy_options.should == {:conditions => "(users.username LIKE 'ben%') OR (users.name LIKE '%ben%')"}
   end
-  
+
   it "should use the last specified condition" do
     User.username_or_name_like_or_id_or_age_lt(10).proxy_options.should == {:conditions => "(users.username LIKE '%10%') OR (users.name LIKE '%10%') OR (users.id < 10) OR (users.age < 10)"}
   end
-  
+
   it "should raise an error on unknown conditions" do
     lambda { User.usernme_begins_with_or_name_like("ben") }.should raise_error(Searchlogic::NamedScopes::OrConditions::UnknownConditionError)
   end
-  
+
   it "should work well with _or_equal_to" do
     User.id_less_than_or_equal_to_or_age_gt(10).proxy_options.should == {:conditions => "(users.id <= 10) OR (users.age > 10)"}
   end
-  
+
   it "should work well with _or_equal_to_any" do
     User.id_less_than_or_equal_to_all_or_age_gt(10).proxy_options.should == {:conditions => "(users.id <= 10) OR (users.age > 10)"}
   end
-  
+
   it "should work well with _or_equal_to_all" do
     User.id_less_than_or_equal_to_any_or_age_gt(10).proxy_options.should == {:conditions => "(users.id <= 10) OR (users.age > 10)"}
   end
-  
+
   it "should play nice with other scopes" do
     User.username_begins_with("ben").id_gt(10).age_not_nil.username_or_name_ends_with("ben").scope(:find).should ==
       {:conditions => "((users.username LIKE '%ben') OR (users.name LIKE '%ben')) AND ((users.age IS NOT NULL) AND ((users.id > 10) AND (users.username LIKE 'ben%')))"}
   end
-  
+
   it "should work with boolean conditions" do
     User.male_or_name_eq("susan").proxy_options.should == {:conditions => %Q{("users"."male" = 't') OR (users.name = 'susan')}}
     User.not_male_or_name_eq("susan").proxy_options.should == {:conditions => %Q{("users"."male" = 'f') OR (users.name = 'susan')}}
     lambda { User.male_or_name_eq("susan").all }.should_not raise_error
   end
-  
+
   it "should play nice with scopes on associations" do
     lambda { User.name_or_company_name_like("ben") }.should_not raise_error(Searchlogic::NamedScopes::OrConditions::NoConditionSpecifiedError)
-    User.name_or_company_name_like("ben").proxy_options.should == {:joins => :company, :conditions => "(users.name LIKE '%ben%') OR (companies.name LIKE '%ben%')"}
-    User.company_name_or_name_like("ben").proxy_options.should == {:joins => :company, :conditions => "(companies.name LIKE '%ben%') OR (users.name LIKE '%ben%')"}
-    User.company_name_or_company_description_like("ben").proxy_options.should == {:joins =>[:company], :conditions => "(companies.name LIKE '%ben%') OR (companies.description LIKE '%ben%')"}
-    Cart.user_company_name_or_user_company_name_like("ben").proxy_options.should == {:joins => {:user=>:company}, :conditions => "(companies.name LIKE '%ben%') OR (companies.name LIKE '%ben%')"}
+    User.name_or_company_name_like("ben").proxy_options.should == {:joins => ["LEFT OUTER JOIN \"companies\" ON \"companies\".id = \"users\".company_id"], :conditions => "(users.name LIKE '%ben%') OR (companies.name LIKE '%ben%')"}
+    User.company_name_or_name_like("ben").proxy_options.should == {:joins => ["LEFT OUTER JOIN \"companies\" ON \"companies\".id = \"users\".company_id"], :conditions => "(companies.name LIKE '%ben%') OR (users.name LIKE '%ben%')"}
+    User.company_name_or_company_description_like("ben").proxy_options.should == {:joins => ["LEFT OUTER JOIN \"companies\" ON \"companies\".id = \"users\".company_id"], :conditions => "(companies.name LIKE '%ben%') OR (companies.description LIKE '%ben%')"}
+    Cart.user_company_name_or_user_company_name_like("ben").proxy_options.should == {:joins => ["LEFT OUTER JOIN \"users\" ON \"carts\".user_id = \"users\".id", "LEFT OUTER JOIN \"companies\" ON \"companies\".id = \"users\".company_id"], :conditions => "(companies.name LIKE '%ben%') OR (companies.name LIKE '%ben%')"}
   end
-  
+
   it "should raise an error on missing condition" do
     lambda { User.id_or_age(123) }.should raise_error(Searchlogic::NamedScopes::OrConditions::NoConditionSpecifiedError)
   end
-  
+
   it "should not get confused by the 'or' in find_or_create_by_* methods" do
     User.create(:name => "Fred")
     User.find_or_create_by_name("Fred").should be_a_kind_of User
@@ -66,12 +66,19 @@
     User.create(:name => "Fred", :username => "fredb")
     User.find_or_create_by_name_and_username("Fred", "fredb").should be_a_kind_of User
   end
-  
+
   it "should work with User.search(conditions) method" do
     User.search(:username_or_name_like => 'ben').proxy_options.should == {:conditions => "(users.username LIKE '%ben%') OR (users.name LIKE '%ben%')"}
   end
 
   it "should convert types properly when used with User.search(conditions) method" do
     User.search(:id_or_age_lte => '10').proxy_options.should == {:conditions => "(users.id <= 10) OR (users.age <= 10)"}
   end
+
+  it "should converts inner joins to left out joins" do
+    scopes = []
+    scopes << User.orders_id_equals(1)
+    scopes << User.carts_id_equals(1)
+    User.send(:merge_scopes_with_or, scopes).should == {:conditions=>"(orders.id = 1) OR (carts.id = 1)", :joins=>["LEFT OUTER JOIN \"carts\" ON carts.user_id = users.id", "LEFT OUTER JOIN \"orders\" ON orders.user_id = users.id"]}
+  end
 end