bullet 4.11.1 → 4.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26834c8b3aa613fbbfb1412e9ca1f110803a1999
-  data.tar.gz: 3663f72e8096a5ea3bdaf10f54679f3e405b958d
+  metadata.gz: f67ea00382954d79e17b7f06299ff2f7654d7ffb
+  data.tar.gz: d7dee9d6ec4ef9903727cce82e1dec6785c9b9ac
 SHA512:
-  metadata.gz: ec4e25e4414f2bda73683bbc21fd417ddaf74d7c09b889bc1d61524a20978ad1ba58d00a9e7636c14e4fa7fbe5589fb5e4cebedc4d1ad9295440e8ba82a215c1
-  data.tar.gz: a0176fa4fa2e434a65fdc349119d130e7302f6deb017e0065b23202009a36488f40bedd8e825875beb2fe004f04f187d785e43cd490fb0fb9f4d39b79c343f07
+  metadata.gz: f30d55932e43fdec7d0c101a9bbb63a55e4661abe8a141f36ef3e702a242790a0e24145ed3e936ecfe47c7d8f7a2ddde94d820dd1da3a594a05e0bfd1946e877
+  data.tar.gz: d893f7f72c0d728bc0475067ef4618c87eb181165eef53939c8e37f4da8c8b2be3d41a17bbc3b2c88dcce4bda1521b52c24102602b9768e5cee9ef7b9f9b9253

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Next Release
 
-## 4.11.0
+## 4.12.0 (not released yet)
+
+* Use primary_key rather than id for bullet_ar_key
+* Rename bullet_ar_key to bullet_key
+* Fix rails sse detect
+
+## 4.11.0 (06/24/2014)
 
 * Support empty? call on ar associations
 * Skip detecting if object is a new record

data/README.md

@@ -180,13 +180,15 @@ Then wrap each test in bullet api.
 
 ```ruby
 # spec/spec_helper.rb
-config.before(:each) do
-  Bullet.start_request if Bullet.enable?
-end
+if Bullet.enable?
+  config.before(:each) do
+    Bullet.start_request
+  end
 
-config.after(:each) do
-  Bullet.perform_out_of_channel_notifications if Bullet.enable? && Bullet.notification?
-  Bullet.end_request if Bullet.enable?
+  config.after(:each) do
+    Bullet.perform_out_of_channel_notifications if Bullet.notification?
+    Bullet.end_request
+  end
 end
 ```
 

data/lib/bullet/detector/association.rb

@@ -7,8 +7,8 @@ module Bullet
           return if !Bullet.n_plus_one_query_enable? && !Bullet.unused_eager_loading_enable?
           return unless object.id
 
-          Bullet.debug("Detector::Association#add_object_associations", "object: #{object.bullet_ar_key}, associations: #{associations}")
-          object_associations.add(object.bullet_ar_key, associations)
+          Bullet.debug("Detector::Association#add_object_associations", "object: #{object.bullet_key}, associations: #{associations}")
+          object_associations.add(object.bullet_key, associations)
         end
 
         def add_call_object_associations(object, associations)
@@ -16,8 +16,8 @@ module Bullet
           return if !Bullet.n_plus_one_query_enable? && !Bullet.unused_eager_loading_enable?
           return unless object.id
 
-          Bullet.debug("Detector::Association#add_call_object_associations", "object: #{object.bullet_ar_key}, associations: #{associations}")
-          call_object_associations.add(object.bullet_ar_key, associations)
+          Bullet.debug("Detector::Association#add_call_object_associations", "object: #{object.bullet_key}, associations: #{associations}")
+          call_object_associations.add(object.bullet_key, associations)
         end
 
         private

data/lib/bullet/detector/counter_cache.rb

@@ -7,8 +7,8 @@ module Bullet
           return unless Bullet.counter_cache_enable?
           return unless object.id
 
-          Bullet.debug("Detector::CounterCache#add_counter_cache", "object: #{object.bullet_ar_key}, associations: #{associations}")
-          if conditions_met?(object.bullet_ar_key, associations)
+          Bullet.debug("Detector::CounterCache#add_counter_cache", "object: #{object.bullet_key}, associations: #{associations}")
+          if conditions_met?(object.bullet_key, associations)
             create_notification object.class.to_s, associations
           end
         end
@@ -19,8 +19,8 @@ module Bullet
           objects = Array(object_or_objects)
           return if objects.map(&:id).compact.empty?
 
-          Bullet.debug("Detector::CounterCache#add_possible_objects", "objects: #{objects.map(&:bullet_ar_key).join(', ')}")
-          objects.each { |object| possible_objects.add object.bullet_ar_key }
+          Bullet.debug("Detector::CounterCache#add_possible_objects", "objects: #{objects.map(&:bullet_key).join(', ')}")
+          objects.each { |object| possible_objects.add object.bullet_key }
         end
 
         def add_impossible_object(object)
@@ -28,8 +28,8 @@ module Bullet
           return unless Bullet.counter_cache_enable?
           return unless object.id
 
-          Bullet.debug("Detector::CounterCache#add_impossible_object", "object: #{object.bullet_ar_key}")
-          impossible_objects.add object.bullet_ar_key
+          Bullet.debug("Detector::CounterCache#add_impossible_object", "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
         end
 
         private
@@ -50,8 +50,8 @@ module Bullet
             Thread.current[:bullet_counter_impossible_objects]
           end
 
-          def conditions_met?(bullet_ar_key, associations)
-            possible_objects.include?(bullet_ar_key) && !impossible_objects.include?(bullet_ar_key)
+          def conditions_met?(bullet_key, associations)
+            possible_objects.include?(bullet_key) && !impossible_objects.include?(bullet_key)
           end
       end
     end

data/lib/bullet/detector/n_plus_one_query.rb

@@ -13,9 +13,9 @@ module Bullet
           return unless object.id
           add_call_object_associations(object, associations)
 
-          Bullet.debug("Detector::NPlusOneQuery#call_association", "object: #{object.bullet_ar_key}, associations: #{associations}")
-          if conditions_met?(object.bullet_ar_key, associations)
-            Bullet.debug("detect n + 1 query", "object: #{object.bullet_ar_key}, associations: #{associations}")
+          Bullet.debug("Detector::NPlusOneQuery#call_association", "object: #{object.bullet_key}, associations: #{associations}")
+          if conditions_met?(object.bullet_key, associations)
+            Bullet.debug("detect n + 1 query", "object: #{object.bullet_key}, associations: #{associations}")
             create_notification caller_in_project, object.class.to_s, associations
           end
         end
@@ -26,8 +26,8 @@ module Bullet
           objects = Array(object_or_objects)
           return if objects.map(&:id).compact.empty?
 
-          Bullet.debug("Detector::NPlusOneQuery#add_possible_objects", "objects: #{objects.map(&:bullet_ar_key).join(', ')}")
-          objects.each { |object| possible_objects.add object.bullet_ar_key }
+          Bullet.debug("Detector::NPlusOneQuery#add_possible_objects", "objects: #{objects.map(&:bullet_key).join(', ')}")
+          objects.each { |object| possible_objects.add object.bullet_key }
         end
 
         def add_impossible_object(object)
@@ -35,8 +35,8 @@ module Bullet
           return unless Bullet.n_plus_one_query_enable?
           return unless object.id
 
-          Bullet.debug("Detector::NPlusOneQuery#add_impossible_object", "object: #{object.bullet_ar_key}")
-          impossible_objects.add object.bullet_ar_key
+          Bullet.debug("Detector::NPlusOneQuery#add_impossible_object", "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
         end
 
         private
@@ -50,8 +50,8 @@ module Bullet
           end
 
           # decide whether the object.associations is unpreloaded or not.
-          def conditions_met?(bullet_ar_key, associations)
-            possible?(bullet_ar_key) && !impossible?(bullet_ar_key) && !association?(bullet_ar_key, associations)
+          def conditions_met?(bullet_key, associations)
+            possible?(bullet_key) && !impossible?(bullet_key) && !association?(bullet_key, associations)
           end
 
           def caller_in_project
@@ -63,17 +63,17 @@ module Bullet
             end
           end
 
-          def possible?(bullet_ar_key)
-            possible_objects.include? bullet_ar_key
+          def possible?(bullet_key)
+            possible_objects.include? bullet_key
           end
 
-          def impossible?(bullet_ar_key)
-            impossible_objects.include? bullet_ar_key
+          def impossible?(bullet_key)
+            impossible_objects.include? bullet_key
           end
 
           # check if object => associations already exists in object_associations.
-          def association?(bullet_ar_key, associations)
-            value = object_associations[bullet_ar_key]
+          def association?(bullet_key, associations)
+            value = object_associations[bullet_key]
             if value
               value.each do |v|
                 result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations

data/lib/bullet/detector/unused_eager_loading.rb

@@ -10,12 +10,12 @@ module Bullet
           return unless Bullet.start?
           return unless Bullet.unused_eager_loading_enable?
 
-          object_associations.each do |bullet_ar_key, associations|
-            object_association_diff = diff_object_associations bullet_ar_key, associations
+          object_associations.each do |bullet_key, associations|
+            object_association_diff = diff_object_associations bullet_key, associations
             next if object_association_diff.empty?
 
-            Bullet.debug("detect unused preload", "object: #{bullet_ar_key}, associations: #{object_association_diff}")
-            create_notification bullet_ar_key.bullet_class_name, object_association_diff
+            Bullet.debug("detect unused preload", "object: #{bullet_key}, associations: #{object_association_diff}")
+            create_notification bullet_key.bullet_class_name, object_association_diff
           end
         end
 
@@ -24,13 +24,13 @@ module Bullet
           return unless Bullet.unused_eager_loading_enable?
           return if objects.map(&:id).compact.empty?
 
-          Bullet.debug("Detector::UnusedEagerLoading#add_eager_loadings", "objects: #{objects.map(&:bullet_ar_key).join(', ')}, associations: #{associations}")
-          bullet_ar_keys = objects.map(&:bullet_ar_key)
+          Bullet.debug("Detector::UnusedEagerLoading#add_eager_loadings", "objects: #{objects.map(&:bullet_key).join(', ')}, associations: #{associations}")
+          bullet_keys = objects.map(&:bullet_key)
 
           to_add = nil
           to_merge, to_delete = [], []
           eager_loadings.each do |k, v|
-            key_objects_overlap = k & bullet_ar_keys
+            key_objects_overlap = k & bullet_keys
 
             next if key_objects_overlap.empty?
 
@@ -40,10 +40,10 @@ module Bullet
             else
               to_merge << [key_objects_overlap, ( eager_loadings[k].dup  << associations )]
 
-              keys_without_objects = k - bullet_ar_keys
+              keys_without_objects = k - bullet_keys
               to_merge << [keys_without_objects, eager_loadings[k]]
               to_delete << k
-              bullet_ar_keys = bullet_ar_keys - k
+              bullet_keys = bullet_keys - k
             end
           end
 
@@ -51,7 +51,7 @@ module Bullet
           to_merge.each { |k,val| eager_loadings.merge k, val }
           to_delete.each { |k| eager_loadings.delete k }
 
-          eager_loadings.add bullet_ar_keys, associations unless bullet_ar_keys.empty?
+          eager_loadings.add bullet_keys, associations unless bullet_keys.empty?
         end
 
         private
@@ -64,18 +64,18 @@ module Bullet
             end
           end
 
-          def call_associations(bullet_ar_key, associations)
+          def call_associations(bullet_key, associations)
             all = Set.new
-            eager_loadings.similarly_associated(bullet_ar_key, associations).each do |related_bullet_ar_key|
-              coa = call_object_associations[related_bullet_ar_key]
+            eager_loadings.similarly_associated(bullet_key, associations).each do |related_bullet_key|
+              coa = call_object_associations[related_bullet_key]
               next if coa.nil?
               all.merge coa
             end
             all.to_a
           end
 
-          def diff_object_associations(bullet_ar_key, associations)
-            potential_associations = associations - call_associations(bullet_ar_key, associations)
+          def diff_object_associations(bullet_key, associations)
+            potential_associations = associations - call_associations(bullet_key, associations)
             potential_associations.reject { |a| a.is_a?(Hash) }
           end
       end

data/lib/bullet/ext/object.rb

@@ -1,5 +1,5 @@
 class Object
-  def bullet_ar_key
+  def bullet_key
     if self.class.respond_to?(:primary_key) && self.class.primary_key
       "#{self.class}:#{self.send self.class.primary_key}"
     else

data/lib/bullet/rack.rb

@@ -51,7 +51,7 @@ module Bullet
     end
 
     def sse?(response)
-      response.respond_to? :stream
+      response.respond_to?(:stream) && response.stream.is_a?(ActionController::Live::Buffer)
     end
 
     def html_request?(headers, response)

data/lib/bullet/registry/object.rb

@@ -1,12 +1,12 @@
 module Bullet
   module Registry
     class Object < Base
-      def add(bullet_ar_key)
-        super(bullet_ar_key.bullet_class_name, bullet_ar_key)
+      def add(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
       end
 
-      def include?(bullet_ar_key)
-        super(bullet_ar_key.bullet_class_name, bullet_ar_key)
+      def include?(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
       end
     end
   end

data/lib/bullet/version.rb

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

data/spec/bullet/detector/association_spec.rb

@@ -11,14 +11,14 @@ module Bullet
       context ".add_object_association" do
         it "should add object, associations pair" do
           Association.add_object_associations(@post1, :associations)
-          expect(Association.send(:object_associations)).to be_include(@post1.bullet_ar_key, :associations)
+          expect(Association.send(:object_associations)).to be_include(@post1.bullet_key, :associations)
         end
       end
 
       context ".add_call_object_associations" do
         it "should add call object, associations pair" do
           Association.add_call_object_associations(@post1, :associations)
-          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_ar_key, :associations)
+          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_key, :associations)
         end
       end
     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_ar_key, [:comments]).and_return(true)
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [: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_ar_key, [:comments]).and_return(false)
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [: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_ar_key)
-          expect(CounterCache.send(:possible_objects)).to be_include(@post2.bullet_ar_key)
+          expect(CounterCache.send(:possible_objects)).to be_include(@post1.bullet_key)
+          expect(CounterCache.send(: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_ar_key)
+          expect(CounterCache.send(: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_ar_key, :associations)).to eq true
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq true
         end
 
         it "should be false when object is not possible" do
-          expect(CounterCache.send(:conditions_met?, @post1.bullet_ar_key, :associations)).to eq false
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :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_ar_key, :associations)).to eq false
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :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_ar_key)).to eq true
+          expect(NPlusOneQuery.send(:possible?, @post.bullet_key)).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_ar_key)).to eq true
+          expect(NPlusOneQuery.send(:impossible?, @post.bullet_key)).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_ar_key, :association)).to eq true
+          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :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_ar_key, :associatio2)).to eq false
+          expect(NPlusOneQuery.send(:association?, @post.bullet_key, :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_ar_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq true
+          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
         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_ar_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq false
+          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
         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_ar_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq false
+          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
         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_ar_key).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post.bullet_ar_key).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post.bullet_ar_key, :associations).and_return(true)
-          expect(NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations)).to eq false
+          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
         end
       end
 
       context ".call_association" do
         it "should create notification if conditions met" do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :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_ar_key, :association).and_return(false)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :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_ar_key, :association).and_return(true)
+          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :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_ar_key, :association).and_return(true)
+            expect(NPlusOneQuery).to receive(:conditions_met?).with(@post.bullet_key, :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_ar_key)
-          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post2.bullet_ar_key)
+          expect(NPlusOneQuery.send(:possible_objects)).to be_include(@post.bullet_key)
+          expect(NPlusOneQuery.send(: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_ar_key)
+          expect(NPlusOneQuery.send(:impossible_objects)).to be_include(@post.bullet_key)
         end
       end
     end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -10,30 +10,30 @@ module Bullet
 
       context ".call_associations" do
         it "should get empty array if eager_loadings" do
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
         end
 
         it "should get call associations if object and association are both in eager_loadings and call_object_associations" do
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association]))).to eq([:association])
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to eq([:association])
         end
 
         it "should not get call associations if not exist in call_object_associations" do
           UnusedEagerLoading.add_eager_loadings([@post], :association)
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
         end
       end
 
       context ".diff_object_associations" do
         it "should return associations not exist in call_association" do
-          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association]))).to eq([:association])
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to eq([:association])
         end
 
         it "should return empty if associations exist in call_association" do
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
-          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to be_empty
         end
       end
 
@@ -48,7 +48,7 @@ module Bullet
           UnusedEagerLoading.add_object_associations(@post, :association)
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
-          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association]))).to be_empty
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to be_empty
           expect(UnusedEagerLoading).not_to receive(:create_notification).with("Post", [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
@@ -57,30 +57,30 @@ module Bullet
       context ".add_eager_loadings" do
         it "should add objects, associations pair when eager_loadings are empty" do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :associations)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :associations)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :associations)
         end
 
         it "should add objects, associations pair for existing eager_loadings" do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association2)
         end
 
         it "should merge objects, associations pair for existing eager_loadings" do
           UnusedEagerLoading.add_eager_loadings([@post], :association1)
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key, @post2.bullet_ar_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key, @post2.bullet_key], :association2)
         end
 
         it "should delete objects, associations pair for existing eager_loadings" do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
           UnusedEagerLoading.add_eager_loadings([@post], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_ar_key], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_ar_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
+          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association1)
         end
       end
     end

data/spec/bullet/ext/object_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe Object do
-  context "bullet_ar_key" do
+  context "bullet_key" do
     it "should return class and id composition" do
       post = Post.first
-      expect(post.bullet_ar_key).to eq("Post:#{post.id}")
+      expect(post.bullet_key).to eq("Post:#{post.id}")
     end
 
     if mongoid?
       it "should return class with namesapce and id composition" do
         post = Mongoid::Post.first
-        expect(post.bullet_ar_key).to eq("Mongoid::Post:#{post.id}")
+        expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
       end
     end
   end

data/spec/bullet/registry/object_spec.rb

@@ -5,18 +5,18 @@ module Bullet
     describe Object do
       let(:post) { Post.first }
       let(:another_post) { Post.last }
-      subject { Object.new.tap { |object| object.add(post.bullet_ar_key) } }
+      subject { Object.new.tap { |object| object.add(post.bullet_key) } }
 
       context "#include?" do
         it "should include the object" do
-          expect(subject).to be_include(post.bullet_ar_key)
+          expect(subject).to be_include(post.bullet_key)
         end
       end
 
       context "#add" do
         it "should add an object" do
-          subject.add(another_post.bullet_ar_key)
-          expect(subject).to be_include(another_post.bullet_ar_key)
+          subject.add(another_post.bullet_key)
+          expect(subject).to be_include(another_post.bullet_key)
         end
       end
     end

data/spec/support/bullet_ext.rb

@@ -33,7 +33,7 @@ module Bullet
 
         # returns true if a given object has a specific association
         def creating_object_association_for?(object, association)
-          object_associations[object.bullet_ar_key].present? && object_associations[object.bullet_ar_key].include?(association)
+          object_associations[object.bullet_key].present? && object_associations[object.bullet_key].include?(association)
         end
 
         # returns true if a given class includes the specific unpreloaded association

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bullet
 version: !ruby/object:Gem::Version
-  version: 4.11.1
+  version: 4.11.2
 platform: ruby
 authors:
 - Richard Huang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-25 00:00:00.000000000 Z
+date: 2014-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport