bullet 2.3.0 → 4.0.0

data/lib/bullet/detector/counter.rb

@@ -8,21 +8,21 @@ module Bullet
         end
 
         def add_counter_cache(object, associations)
-          if conditions_met?(object.ar_key, associations)
+          if conditions_met?(object.bullet_ar_key, associations)
             create_notification object.class.to_s, associations
           end
         end
 
         def add_possible_objects(object_or_objects)
           if object_or_objects.is_a? Array
-            object_or_objects.each { |object| possible_objects.add object.ar_key }
+            object_or_objects.each { |object| possible_objects.add object.bullet_ar_key }
           else
-            possible_objects.add object_or_objects.ar_key
+            possible_objects.add object_or_objects.bullet_ar_key
           end
         end
 
         def add_impossible_object(object)
-          impossible_objects.add object.ar_key
+          impossible_objects.add object.bullet_ar_key
         end
 
         private
@@ -39,8 +39,8 @@ module Bullet
             @@impossible_objects ||= Bullet::Registry::Object.new
           end
 
-          def conditions_met?(object_ar_key, associations)
-            possible_objects.include?(object_ar_key) && !impossible_objects.include?(object_ar_key)
+          def conditions_met?(bullet_ar_key, associations)
+            possible_objects.include?(bullet_ar_key) && !impossible_objects.include?(bullet_ar_key)
           end
       end
     end

data/lib/bullet/detector/n_plus_one_query.rb

@@ -10,7 +10,7 @@ module Bullet
           @@checked = true
           add_call_object_associations(object, associations)
 
-          if conditions_met?(object.ar_key, associations)
+          if conditions_met?(object.bullet_ar_key, associations)
             create_notification caller_in_project, object.class.to_s, associations
           end
         end
@@ -22,8 +22,8 @@ module Bullet
           end
 
           # decide whether the object.associations is unpreloaded or not.
-          def conditions_met?(object_ar_key, associations)
-            possible?(object_ar_key) && !impossible?(object_ar_key) && !association?(object_ar_key, associations)
+          def conditions_met?(bullet_ar_key, associations)
+            possible?(bullet_ar_key) && !impossible?(bullet_ar_key) && !association?(bullet_ar_key, associations)
           end
 
           def caller_in_project
@@ -32,17 +32,17 @@ module Bullet
             caller.select { |c| c.include?(rails_root) && !c.include?(vendor_root) }
           end
 
-          def possible?(object_ar_key)
-            possible_objects.include? object_ar_key
+          def possible?(bullet_ar_key)
+            possible_objects.include? bullet_ar_key
           end
 
-          def impossible?(object_ar_key)
-            impossible_objects.include? object_ar_key
+          def impossible?(bullet_ar_key)
+            impossible_objects.include? bullet_ar_key
           end
 
           # check if object => associations already exists in object_associations.
-          def association?(object_ar_key, associations)
-            value = object_associations[object_ar_key]
+          def association?(bullet_ar_key, associations)
+            value = object_associations[bullet_ar_key]
             if value
               value.each do |v|
                 result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations

data/lib/bullet/detector/unused_eager_association.rb

@@ -8,11 +8,11 @@ module Bullet
         #   if association not in call_object_association, then the object => association - call_object_association is ununsed preload assocations
         def check_unused_preload_associations
           @@checked = true
-          object_associations.each do |object_ar_key, association|
-            object_association_diff = diff_object_association object_ar_key, association
+          object_associations.each do |bullet_ar_key, associations|
+            object_association_diff = diff_object_associations bullet_ar_key, associations
             next if object_association_diff.empty?
 
-            create_notification object_ar_key.split(":").first, object_association_diff
+            create_notification bullet_ar_key.bullet_class_name, object_association_diff
           end
         end
 
@@ -22,19 +22,19 @@ module Bullet
             Bullet.notification_collector.add(notice)
           end
 
-          def call_associations(object_ar_key, association)
+          def call_associations(bullet_ar_key, associations)
             all = Set.new
-            eager_loadings.similarly_associated(object_ar_key, association).each do |related_object_ar_key|
-              coa = call_object_associations[related_object_ar_key]
+            eager_loadings.similarly_associated(bullet_ar_key, associations).each do |related_bullet_ar_key|
+              coa = call_object_associations[related_bullet_ar_key]
               next if coa.nil?
               all.merge coa
             end
             all.to_a
           end
 
-          def diff_object_association(object_ar_key, association)
-            potential_objects = association - call_associations(object_ar_key, association)
-            potential_objects.reject { |a| a.is_a?(Hash) }
+          def diff_object_associations(bullet_ar_key, associations)
+            potential_associations = associations - call_associations(bullet_ar_key, associations)
+            potential_associations.reject { |a| a.is_a?(Hash) }
           end
       end
     end

data/lib/bullet/ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def bullet_ar_key
+    "#{self.class}:#{self.id}"
+  end
+end

data/lib/bullet/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def bullet_class_name
+    self.sub(/:[^:]*?$/, "")
+  end
+end

data/lib/bullet/mongoid.rb

@@ -0,0 +1,56 @@
+module Bullet
+  module Mongoid
+    def self.enable
+      require 'mongoid'
+      ::Mongoid::Contexts::Mongo.class_eval do
+        alias_method :origin_first, :first
+        alias_method :origin_last, :last
+        alias_method :origin_iterate, :iterate
+
+        def first
+          result = origin_first
+          Bullet::Detector::Association.add_impossible_object(result)
+          result
+        end
+
+        def last
+          result = origin_last
+          Bullet::Detector::Association.add_impossible_object(result)
+          result
+        end
+
+        def iterate(&block)
+          records = execute.to_a
+          if records.size > 1
+            Bullet::Detector::Association.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::Association.add_impossible_object(records.first)
+          end
+          origin_iterate(&block)
+        end
+      end
+
+      ::Mongoid::Relations::Accessors.class_eval do
+        alias_method :origin_set_relation, :set_relation
+
+        def set_relation(name, relation)
+          Bullet::Detector::NPlusOneQuery.call_association(self, name)
+          origin_set_relation(name, relation)
+        end
+      end
+
+      ::Mongoid::Contexts::Mongo.class_eval do
+        alias_method :origin_eager_load, :eager_load
+
+        def eager_load(docs)
+          associations = criteria.inclusions.map(&:name)
+          docs.each do |doc|
+            Bullet::Detector::Association.add_object_associations(doc, associations)
+          end
+          Bullet::Detector::Association.add_eager_loadings(docs, associations)
+          origin_eager_load(docs)
+        end
+      end
+    end
+  end
+end

data/lib/bullet/registry/object.rb

@@ -1,14 +1,12 @@
 module Bullet
   module Registry
     class Object < Base
-      def add(object_ar_key)
-        klazz = object_ar_key.split(":").first
-        super(klazz, object_ar_key)
+      def add(bullet_ar_key)
+        super(bullet_ar_key.bullet_class_name, bullet_ar_key)
       end
 
-      def include?(object_ar_key)
-        klazz = object_ar_key.split(":").first
-        super(klazz, object_ar_key)
+      def include?(bullet_ar_key)
+        super(bullet_ar_key.bullet_class_name, bullet_ar_key)
       end
     end
   end

data/lib/bullet/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module Bullet
-  VERSION = "2.3.0"
+  VERSION = "4.0.0"
 end
 

data/lib/bullet.rb

@@ -1,11 +1,7 @@
 require 'set'
 require 'uniform_notifier'
-
-class Object
-  def ar_key
-    "#{self.class}:#{self.id}"
-  end
-end
+require 'bullet/ext/object'
+require 'bullet/ext/string'
 
 module Bullet
   if Rails.version =~ /\A3\.0/
@@ -16,6 +12,7 @@ module Bullet
     autoload :ActiveRecord, 'bullet/active_record2'
     autoload :ActionController, 'bullet/action_controller2'
   end
+  autoload :Mongoid, 'bullet/mongoid'
   autoload :Rack, 'bullet/rack'
   autoload :BulletLogger, 'bullet/logger'
   autoload :Notification, 'bullet/notification'
@@ -44,9 +41,18 @@ module Bullet
     def enable=(enable)
       @enable = enable
       if enable?
-        Bullet::ActiveRecord.enable
-        if Rails.version =~ /\A2./
-          Bullet::ActionController.enable
+        begin
+          require 'mongoid'
+          Bullet::Mongoid.enable
+        rescue LoadError
+        end
+        begin
+          require 'active_record'
+          Bullet::ActiveRecord.enable
+          if Rails.version =~ /\A2./
+            Bullet::ActionController.enable
+          end
+        rescue LoadError
         end
       end
     end

data/spec/bullet/detector/association_spec.rb

@@ -30,59 +30,63 @@ module Bullet
       context ".add_object_association" do
         it "should add object, associations pair" do
           Association.add_object_associations(@post1, :associations)
-          Association.send(:object_associations).should be_include(@post1.ar_key, :associations)
+          Association.send(:object_associations).should be_include(@post1.bullet_ar_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)
-          Association.send(:call_object_associations).should be_include(@post1.ar_key, :associations)
+          Association.send(:call_object_associations).should be_include(@post1.bullet_ar_key, :associations)
         end
       end
 
       context ".add_possible_objects" do
         it "should add possible objects" do
           Association.add_possible_objects([@post1, @post2])
-          Association.send(:possible_objects).should be_include(@post1.ar_key)
-          Association.send(:possible_objects).should be_include(@post2.ar_key)
+          Association.send(:possible_objects).should be_include(@post1.bullet_ar_key)
+          Association.send(:possible_objects).should be_include(@post2.bullet_ar_key)
+        end
+
+        it "should not raise error if object is nil" do
+          lambda { Association.add_possible_objects(nil) }.should_not raise_error
         end
       end
 
       context ".add_impossible_object" do
         it "should add impossible object" do
           Association.add_impossible_object(@post1)
-          Association.send(:impossible_objects).should be_include(@post1.ar_key)
+          Association.send(:impossible_objects).should be_include(@post1.bullet_ar_key)
         end
       end
 
       context ".add_eager_loadings" do
         it "should add objects, associations pair when eager_loadings are empty" do
           Association.add_eager_loadings([@post1, @post2], :associations)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :associations)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :associations)
         end
 
         it "should add objects, associations pair for existing eager_loadings" do
           Association.add_eager_loadings([@post1, @post2], :association1)
           Association.add_eager_loadings([@post1, @post2], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :association1)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :association1)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :association2)
         end
 
         it "should merge objects, associations pair for existing eager_loadings" do
-          Association.add_eager_loadings(@post1, :association1)
+          Association.add_eager_loadings([@post1], :association1)
           Association.add_eager_loadings([@post1, @post2], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association1)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association2)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key, @post2.ar_key], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association1)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key, @post2.bullet_ar_key], :association2)
         end
 
         it "should delete objects, associations pair for existing eager_loadings" do
           Association.add_eager_loadings([@post1, @post2], :association1)
-          Association.add_eager_loadings(@post1, :association2)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association1)
-          Association.send(:eager_loadings).should be_include([@post1.ar_key], :association2)
-          Association.send(:eager_loadings).should be_include([@post2.ar_key], :association1)
+          Association.add_eager_loadings([@post1], :association2)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association1)
+          Association.send(:eager_loadings).should be_include([@post1.bullet_ar_key], :association2)
+          Association.send(:eager_loadings).should be_include([@post2.bullet_ar_key], :association1)
         end
       end
     end

data/spec/bullet/detector/counter_spec.rb

@@ -11,7 +11,6 @@ module Bullet
 
       context ".clear" do
         it "should clear all class variables" do
-          Counter.clear
           Counter.class_variable_get(:@@possible_objects).should be_nil
           Counter.class_variable_get(:@@impossible_objects).should be_nil
         end
@@ -19,13 +18,13 @@ module Bullet
 
       context ".add_counter_cache" do
         it "should create notification if conditions met" do
-          Counter.should_receive(:conditions_met?).with(@post1.ar_key, [:comments]).and_return(true)
+          Counter.should_receive(:conditions_met?).with(@post1.bullet_ar_key, [:comments]).and_return(true)
           Counter.should_receive(:create_notification).with("Post", [:comments])
           Counter.add_counter_cache(@post1, [:comments])
         end
 
         it "should not create notification if conditions not met" do
-          Counter.should_receive(:conditions_met?).with(@post1.ar_key, [:comments]).and_return(false)
+          Counter.should_receive(:conditions_met?).with(@post1.bullet_ar_key, [:comments]).and_return(false)
           Counter.should_receive(:create_notification).never
           Counter.add_counter_cache(@post1, [:comments])
         end
@@ -34,30 +33,30 @@ module Bullet
       context ".add_possible_objects" do
         it "should add possible objects" do
           Counter.add_possible_objects([@post1, @post2])
-          Counter.send(:possible_objects).should be_include(@post1.ar_key)
-          Counter.send(:possible_objects).should be_include(@post2.ar_key)
+          Counter.send(:possible_objects).should be_include(@post1.bullet_ar_key)
+          Counter.send(:possible_objects).should be_include(@post2.bullet_ar_key)
         end
 
         it "should add impossible object" do
           Counter.add_impossible_object(@post1)
-          Counter.send(:impossible_objects).should be_include(@post1.ar_key)
+          Counter.send(:impossible_objects).should be_include(@post1.bullet_ar_key)
         end
       end
 
       context ".conditions_met?" do
         it "should be true when object is possible, not impossible" do
           Counter.add_possible_objects(@post1)
-          Counter.send(:conditions_met?, @post1.ar_key, :associations).should be_true
+          Counter.send(:conditions_met?, @post1.bullet_ar_key, :associations).should be_true
         end
 
         it "should be false when object is not possible" do
-          Counter.send(:conditions_met?, @post1.ar_key, :associations).should be_false
+          Counter.send(:conditions_met?, @post1.bullet_ar_key, :associations).should be_false
         end
 
         it "should be true when object is possible, and impossible" do
           Counter.add_possible_objects(@post1)
           Counter.add_impossible_object(@post1)
-          Counter.send(:conditions_met?, @post1.ar_key, :associations).should be_false
+          Counter.send(:conditions_met?, @post1.bullet_ar_key, :associations).should be_false
         end
       end
     end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -21,69 +21,69 @@ module Bullet
       context ".possible?" do
         it "should be true if possible_objects contain" do
           NPlusOneQuery.add_possible_objects(@post)
-          NPlusOneQuery.send(:possible?, @post.ar_key).should be_true
+          NPlusOneQuery.send(:possible?, @post.bullet_ar_key).should be_true
         end
       end
 
       context ".impossible?" do
         it "should be true if impossible_objects contain" do
           NPlusOneQuery.add_impossible_object(@post)
-          NPlusOneQuery.send(:impossible?, @post.ar_key).should be_true
+          NPlusOneQuery.send(:impossible?, @post.bullet_ar_key).should be_true
         end
       end
 
       context ".association?" do
         it "should be true if object, associations pair is already existed" do
           NPlusOneQuery.add_object_associations(@post, :association)
-          NPlusOneQuery.send(:association?, @post.ar_key, :association).should be_true
+          NPlusOneQuery.send(:association?, @post.bullet_ar_key, :association).should be_true
         end
 
         it "should be false if object, association pair is not existed" do
           NPlusOneQuery.add_object_associations(@post, :association1)
-          NPlusOneQuery.send(:association?, @post.ar_key, :associatio2).should be_false
+          NPlusOneQuery.send(:association?, @post.bullet_ar_key, :associatio2).should be_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
-          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(true)
-          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(false)
-          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(false)
-          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_true
+          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(true)
+          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(false)
+          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
+          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_true
         end
 
         it "should be false if object is not possible, not impossible and object, associations pair is not already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(false)
-          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(false)
-          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(false)
-          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_false
+          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(false)
+          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(false)
+          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
+          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_false
         end
 
         it "should be false if object is possible, but impossible and object, associations pair is not already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(true)
-          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(true)
-          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(false)
-          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_false
+          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(true)
+          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(true)
+          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(false)
+          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_false
         end
 
         it "should be false if object is possible, not impossible and object, associations pair is already existed" do
-          NPlusOneQuery.stub(:possible?).with(@post.ar_key).and_return(true)
-          NPlusOneQuery.stub(:impossible?).with(@post.ar_key).and_return(false)
-          NPlusOneQuery.stub(:association?).with(@post.ar_key, :associations).and_return(true)
-          NPlusOneQuery.send(:conditions_met?, @post.ar_key, :associations).should be_false
+          NPlusOneQuery.stub(:possible?).with(@post.bullet_ar_key).and_return(true)
+          NPlusOneQuery.stub(:impossible?).with(@post.bullet_ar_key).and_return(false)
+          NPlusOneQuery.stub(:association?).with(@post.bullet_ar_key, :associations).and_return(true)
+          NPlusOneQuery.send(:conditions_met?, @post.bullet_ar_key, :associations).should be_false
         end
       end
 
       context ".call_association" do
         it "should create notification if conditions met" do
-          NPlusOneQuery.should_receive(:conditions_met?).with(@post.ar_key, :association).and_return(true)
+          NPlusOneQuery.should_receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(true)
           NPlusOneQuery.should_receive(:caller_in_project).and_return(["caller"])
           NPlusOneQuery.should_receive(:create_notification).with(["caller"], "Post", :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
         it "should not create notification if conditions not met" do
-          NPlusOneQuery.should_receive(:conditions_met?).with(@post.ar_key, :association).and_return(false)
+          NPlusOneQuery.should_receive(:conditions_met?).with(@post.bullet_ar_key, :association).and_return(false)
           NPlusOneQuery.should_not_receive(:caller_in_project!)
           NPlusOneQuery.should_not_receive(:create_notification).with("Post", :association)
           NPlusOneQuery.call_association(@post, :association)

data/spec/bullet/detector/unused_eager_association_spec.rb

@@ -8,30 +8,30 @@ module Bullet
 
       context ".call_associations" do
         it "should get empty array if eager_loadgins" do
-          UnusedEagerAssociation.send(:call_associations, @post.ar_key, Set.new([:association])).should be_empty
+          UnusedEagerAssociation.send(:call_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
         end
 
         it "should get call associations if object and association are both in eager_loadings and call_object_associations" do
-          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.add_eager_loadings([@post], :association)
           UnusedEagerAssociation.add_call_object_associations(@post, :association)
-          UnusedEagerAssociation.send(:call_associations, @post.ar_key, Set.new([:association])).should == [:association]
+          UnusedEagerAssociation.send(:call_associations, @post.bullet_ar_key, Set.new([:association])).should == [:association]
         end
 
         it "should not get call associations if not exist in call_object_associations" do
-          UnusedEagerAssociation.add_eager_loadings(@post, :association)
-          UnusedEagerAssociation.send(:call_associations, @post.ar_key, Set.new([:association])).should be_empty
+          UnusedEagerAssociation.add_eager_loadings([@post], :association)
+          UnusedEagerAssociation.send(:call_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
         end
       end
 
-      context ".diff_object_association" do
+      context ".diff_object_associations" do
         it "should return associations not exist in call_association" do
-          UnusedEagerAssociation.send(:diff_object_association, @post.ar_key, Set.new([:association])).should == [:association]
+          UnusedEagerAssociation.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association])).should == [:association]
         end
 
         it "should return empty if associations exist in call_association" do
-          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.add_eager_loadings([@post], :association)
           UnusedEagerAssociation.add_call_object_associations(@post, :association)
-          UnusedEagerAssociation.send(:diff_object_association, @post.ar_key, Set.new([:association])).should be_empty
+          UnusedEagerAssociation.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
         end
       end
 
@@ -50,9 +50,9 @@ module Bullet
         it "should not create notification if object_association_diff is empty" do
           UnusedEagerAssociation.clear
           UnusedEagerAssociation.add_object_associations(@post, :association)
-          UnusedEagerAssociation.add_eager_loadings(@post, :association)
+          UnusedEagerAssociation.add_eager_loadings([@post], :association)
           UnusedEagerAssociation.add_call_object_associations(@post, :association)
-          UnusedEagerAssociation.send(:diff_object_association, @post.ar_key, Set.new([:association])).should be_empty
+          UnusedEagerAssociation.send(:diff_object_associations, @post.bullet_ar_key, Set.new([:association])).should be_empty
           UnusedEagerAssociation.should_not_receive(:create_notification).with("Post", [:association])
           UnusedEagerAssociation.check_unused_preload_associations
         end

data/spec/bullet/ext/object_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Object do
+  context "bullet_ar_key" do
+    it "should return class and id composition" do
+      post = Post.first
+      post.bullet_ar_key.should == "Post:#{post.id}"
+    end
+
+    begin
+      require 'mongoid'
+
+      it "should return class with namesapce and id composition" do
+        post = Mongoid::Post.first
+        post.bullet_ar_key.should == "Mongoid::Post:#{post.id}"
+      end
+    rescue LoadError
+    end
+  end
+end

data/spec/bullet/ext/string_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe String do
+  context "bullet_class_name" do
+    it "should only return class name" do
+      "Post:1".bullet_class_name.should == "Post"
+    end
+
+    it "should return class name with namespace" do
+      "Mongoid::Post:1234567890".bullet_class_name.should == "Mongoid::Post"
+    end
+  end
+end

data/spec/bullet/registry/object_spec.rb

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