bullet 4.14.5 → 4.14.6

data/lib/bullet/detector/n_plus_one_query.rb

@@ -15,7 +15,7 @@ module Bullet
           add_call_object_associations(object, associations)
 
           Bullet.debug("Detector::NPlusOneQuery#call_association", "object: #{object.bullet_key}, associations: #{associations}")
-          if conditions_met?(object.bullet_key, associations)
+          if conditions_met?(object, associations)
             Bullet.debug("detect n + 1 query", "object: #{object.bullet_key}, associations: #{associations}")
             create_notification caller_in_project, object.class.to_s, associations
           end
@@ -49,6 +49,35 @@ module Bullet
           inversed_objects.add object.bullet_key, association
         end
 
+        # decide whether the object.associations is unpreloaded or not.
+        def conditions_met?(object, associations)
+          possible?(object) && !impossible?(object) && !association?(object, associations)
+        end
+
+        def possible?(object)
+          possible_objects.include? object.bullet_key
+        end
+
+        def impossible?(object)
+          impossible_objects.include? object.bullet_key
+        end
+
+        # check if object => associations already exists in object_associations.
+        def association?(object, associations)
+          value = object_associations[object.bullet_key]
+          if value
+            value.each do |v|
+              # associations == v comparision order is important here because
+              # v variable might be a squeel node where :== method is redefined,
+              # so it does not compare values at all and return unexpected results
+              result = v.is_a?(Hash) ? v.has_key?(associations) : associations == v
+              return true if result
+            end
+          end
+
+          false
+        end
+
         private
           def create_notification(callers, klazz, associations)
             notify_associations = Array(associations) - Bullet.get_whitelist_associations(:n_plus_one_query, klazz)
@@ -59,11 +88,6 @@ module Bullet
             end
           end
 
-          # decide whether the object.associations is unpreloaded or not.
-          def conditions_met?(bullet_key, associations)
-            possible?(bullet_key) && !impossible?(bullet_key) && !association?(bullet_key, associations)
-          end
-
           def caller_in_project
             app_root = rails? ? Rails.root.to_s : Dir.pwd
             vendor_root = app_root + "/vendor"
@@ -72,30 +96,6 @@ module Bullet
               Bullet.stacktrace_includes.any? { |include| c.include?(include) }
             end
           end
-
-          def possible?(bullet_key)
-            possible_objects.include? bullet_key
-          end
-
-          def impossible?(bullet_key)
-            impossible_objects.include? bullet_key
-          end
-
-          # check if object => associations already exists in object_associations.
-          def association?(bullet_key, associations)
-            value = object_associations[bullet_key]
-            if value
-              value.each do |v|
-                # associations == v comparision order is important here because
-                # v variable might be a squeel node where :== method is redefined,
-                # so it does not compare values at all and return unexpected results
-                result = v.is_a?(Hash) ? v.has_key?(associations) : associations == v
-                return true if result
-              end
-            end
-
-            return false
-          end
       end
     end
   end

data/lib/bullet/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Bullet
-  VERSION = "4.14.5"
+  VERSION = "4.14.6"
 end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -10,13 +10,13 @@ module Bullet
 
       context ".add_counter_cache" do
         it "should create notification if conditions met" do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(true)
+          expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(true)
           expect(CounterCache).to receive(:create_notification).with("Post", [:comments])
           CounterCache.add_counter_cache(@post1, [:comments])
         end
 
         it "should not create notification if conditions not met" do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(false)
+          expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(false)
           expect(CounterCache).to receive(:create_notification).never
           CounterCache.add_counter_cache(@post1, [:comments])
         end
@@ -25,30 +25,30 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           CounterCache.add_possible_objects([@post1, @post2])
-          expect(CounterCache.send(:possible_objects)).to be_include(@post1.bullet_key)
-          expect(CounterCache.send(:possible_objects)).to be_include(@post2.bullet_key)
+          expect(CounterCache.possible_objects).to be_include(@post1.bullet_key)
+          expect(CounterCache.possible_objects).to be_include(@post2.bullet_key)
         end
 
         it "should add impossible object" do
           CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.send(:impossible_objects)).to be_include(@post1.bullet_key)
+          expect(CounterCache.impossible_objects).to be_include(@post1.bullet_key)
         end
       end
 
       context ".conditions_met?" do
         it "should be true when object is possible, not impossible" do
           CounterCache.add_possible_objects(@post1)
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq true
+          expect(CounterCache.conditions_met?(@post1, :associations)).to eq true
         end
 
         it "should be false when object is not possible" do
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
 
         it "should be true when object is possible, and impossible" do
           CounterCache.add_possible_objects(@post1)
           CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
       end
     end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -18,69 +18,69 @@ module Bullet
       context ".possible?" do
         it "should be true if possible_objects contain" do
           NPlusOneQuery.add_possible_objects(@post)
-          expect(NPlusOneQuery.send(:possible?, @post.bullet_key)).to eq true
+          expect(NPlusOneQuery.possible?(@post)).to eq true
         end
       end
 
       context ".impossible?" do
         it "should be true if impossible_objects contain" do
           NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.send(:impossible?, @post.bullet_key)).to eq true
+          expect(NPlusOneQuery.impossible?(@post)).to eq true
         end
       end
 
       context ".association?" do
         it "should be true if object, associations pair is already existed" do
           NPlusOneQuery.add_object_associations(@post, :association)
-          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :association)).to eq true
+          expect(NPlusOneQuery.association?(@post, :association)).to eq true
         end
 
         it "should be false if object, association pair is not existed" do
           NPlusOneQuery.add_object_associations(@post, :association1)
-          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :associatio2)).to eq false
+          expect(NPlusOneQuery.association?(@post, :associatio2)).to eq false
         end
       end
 
       context ".conditions_met?" do
         it "should be true if object is possible, not impossible and object, associations pair is not already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq true
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq true
         end
 
         it "should be false if object is not possible, not impossible and object, associations pair is not already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
         end
 
         it "should be false if object is possible, but impossible and object, associations pair is not already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
         end
 
         it "should be false if object is possible, not impossible and object, associations pair is already existed" do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post.bullet_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_key, :associations).and_return(true)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_key, :associations)).to eq false
+          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
+          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
+          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(true)
+          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
         end
       end
 
       context ".call_association" do
         it "should create notification if conditions met" do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
           expect(NPlusOneQuery).to receive(:caller_in_project).and_return(["caller"])
           expect(NPlusOneQuery).to receive(:create_notification).with(["caller"], "Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
         it "should not create notification if conditions not met" do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(false)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(false)
           expect(NPlusOneQuery).not_to receive(:caller_in_project!)
           expect(NPlusOneQuery).not_to receive(:create_notification).with("Post", :association)
           NPlusOneQuery.call_association(@post, :association)
@@ -93,7 +93,7 @@ module Bullet
           not_in_project = '/def/def.rb'
 
           expect(NPlusOneQuery).to receive(:caller).and_return([in_project, not_in_project])
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
           expect(NPlusOneQuery).to receive(:create_notification).with([in_project], "Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
@@ -108,7 +108,7 @@ module Bullet
             excluded_gem = '/ghi/ghi.rb'
 
             expect(NPlusOneQuery).to receive(:caller).and_return([in_project, included_gem, excluded_gem])
-            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :association).and_return(true)
+            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
             expect(NPlusOneQuery).to receive(:create_notification).with([in_project, included_gem], "Post", :association)
             NPlusOneQuery.call_association(@post, :association)
           end
@@ -118,8 +118,8 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           NPlusOneQuery.add_possible_objects([@post, @post2])
-          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post.bullet_key)
-          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post2.bullet_key)
+          expect(NPlusOneQuery.possible_objects).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.possible_objects).to be_include(@post2.bullet_key)
         end
 
         it "should not raise error if object is nil" do
@@ -130,7 +130,7 @@ module Bullet
       context ".add_impossible_object" do
         it "should add impossible object" do
           NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.send(:impossible_objects)).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.impossible_objects).to be_include(@post.bullet_key)
         end
       end
     end

data/spec/integration/active_record3/association_spec.rb

@@ -335,6 +335,15 @@ if !mongoid? && active_record3?
         expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Comment, :post)
       end
 
+      it "should not detect non preload association with only one comment" do
+        Comment.first.post.category.name
+
+        Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+        expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
+
+        expect(Bullet::Detector::Association).to be_completely_preloading_associations
+      end
+
       it "should detect non preload association with post => category" do
         Comment.includes(:post).each do |comment|
           comment.post.category.name

data/spec/integration/active_record4/association_spec.rb

@@ -347,6 +347,15 @@ if !mongoid? && active_record4?
         expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Comment, :post)
       end
 
+      it "should not detect non preload association with only one comment" do
+        Comment.first.post.category.name
+
+        Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+        expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
+
+        expect(Bullet::Detector::Association).to be_completely_preloading_associations
+      end
+
       it "should detect non preload association with post => category" do
         Comment.includes(:post).each do |comment|
           comment.post.category.name

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bullet
 version: !ruby/object:Gem::Version
-  version: 4.14.5
+  version: 4.14.6
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-19 00:00:00.000000000 Z
+date: 2015-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -184,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: help to kill N+1 queries and unused eager loading.