bullet 5.6.0 → 5.7.0

data/lib/bullet/notification/unused_eager_loading.rb

@@ -22,8 +22,9 @@ module Bullet
       end
 
       protected
+
         def call_stack_messages
-          (['Call stack'] + @callers).join( "\n  " )
+          (['Call stack'] + @callers).join("\n  ")
         end
     end
   end

data/lib/bullet/rack.rb

@@ -14,7 +14,7 @@ module Bullet
       response_body = nil
       if Bullet.notification?
         if !file?(headers) && !sse?(headers) && !empty?(response) &&
-            status == 200 && !response_body(response).frozen? && html_request?(headers, response)
+           status == 200 && !response_body(response).frozen? && html_request?(headers, response)
           response_body = response_body(response)
           append_to_html_body(response_body, footer_note) if Bullet.add_footer
           append_to_html_body(response_body, Bullet.gather_inline_notifications)
@@ -51,19 +51,19 @@ module Bullet
     end
 
     def footer_note
-      "<div #{footer_div_attributes}>" + footer_close_button + Bullet.footer_info.uniq.join("<br>") + "</div>"
+      "<div #{footer_div_attributes}>" + footer_close_button + Bullet.footer_info.uniq.join('<br>') + '</div>'
     end
 
     def file?(headers)
-      headers["Content-Transfer-Encoding"] == "binary" || headers["Content-Disposition"]
+      headers['Content-Transfer-Encoding'] == 'binary' || headers['Content-Disposition']
     end
 
     def sse?(headers)
-      headers["Content-Type"] == "text/event-stream"
+      headers['Content-Type'] == 'text/event-stream'
     end
 
     def html_request?(headers, response)
-      headers['Content-Type'] && headers['Content-Type'].include?('text/html') && response_body(response).include?("<html")
+      headers['Content-Type'] && headers['Content-Type'].include?('text/html') && response_body(response).include?('<html')
     end
 
     def response_body(response)

data/lib/bullet/stack_trace_filter.rb

@@ -1,12 +1,12 @@
 module Bullet
   module StackTraceFilter
-    VENDOR_PATH = "/vendor"
+    VENDOR_PATH = '/vendor'.freeze
 
     def caller_in_project
       app_root = rails? ? Rails.root.to_s : Dir.pwd
       vendor_root = app_root + VENDOR_PATH
       caller_locations.select do |location|
-        caller_path = location.absolute_path
+        caller_path = location.absolute_path.to_s
         caller_path.include?(app_root) && !caller_path.include?(vendor_root) ||
           Bullet.stacktrace_includes.any? do |include_pattern|
           case include_pattern

data/lib/bullet/version.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+
 module Bullet
-  VERSION = "5.6.0"
+  VERSION = '5.7.0'.freeze
 end

data/lib/bullet.rb

@@ -1,4 +1,4 @@
-require "active_support/core_ext/module/delegation"
+require 'active_support/core_ext/module/delegation'
 require 'set'
 require 'uniform_notifier'
 require 'bullet/ext/object'
@@ -22,7 +22,7 @@ module Bullet
 
   if defined? Rails::Railtie
     class BulletRailtie < Rails::Railtie
-      initializer "bullet.configure_rails_initialization" do |app|
+      initializer 'bullet.configure_rails_initialization' do |app|
         app.middleware.use Bullet::Rack
       end
     end
@@ -38,12 +38,12 @@ module Bullet
     delegate *available_notifiers
 
     def raise=(should_raise)
-      UniformNotifier.raise=(should_raise ? Notification::UnoptimizedQueryError : false)
+      UniformNotifier.raise = (should_raise ? Notification::UnoptimizedQueryError : false)
     end
 
-    DETECTORS = [ Bullet::Detector::NPlusOneQuery,
+    DETECTORS = [Bullet::Detector::NPlusOneQuery,
                   Bullet::Detector::UnusedEagerLoading,
-                  Bullet::Detector::CounterCache ]
+                  Bullet::Detector::CounterCache].freeze
 
     def enable=(enable)
       @enable = @n_plus_one_query_enable = @unused_eager_loading_enable = @counter_cache_enable = enable
@@ -87,12 +87,19 @@ module Bullet
       @whitelist[options[:type]][options[:class_name]] << options[:association].to_sym
     end
 
+    def delete_whitelist(options)
+      reset_whitelist
+      @whitelist[options[:type]][options[:class_name]] ||= []
+      @whitelist[options[:type]][options[:class_name]].delete(options[:association].to_sym)
+      @whitelist[options[:type]].delete_if { |key, val| val.empty? }
+    end
+
     def get_whitelist_associations(type, class_name)
       Array(@whitelist[type][class_name])
     end
 
     def reset_whitelist
-      @whitelist ||= {:n_plus_one_query => {}, :unused_eager_loading => {}, :counter_cache => {}}
+      @whitelist ||= { :n_plus_one_query => {}, :unused_eager_loading => {}, :counter_cache => {} }
     end
 
     def clear_whitelist
@@ -163,7 +170,7 @@ module Bullet
       for_each_active_notifier_with_notification do |notification|
         responses << notification.notify_inline
       end
-      responses.join( "\n" )
+      responses.join("\n")
     end
 
     def perform_out_of_channel_notifications(env = {})
@@ -211,6 +218,7 @@ module Bullet
     end
 
     private
+
       def for_each_active_notifier_with_notification
         UniformNotifier.active_notifiers.each do |notifier|
           notification_collector.collection.each do |notification|

data/lib/generators/bullet/install_generator.rb

@@ -7,7 +7,7 @@ Description:
       DESC
 
       def enable_in_development
-        environment(nil, env: "development") do
+        environment(nil, env: 'development') do
           <<-"FILE".strip
 
   config.after_initialize do
@@ -22,12 +22,12 @@ Description:
           FILE
         end
 
-        say "Enabled bullet in config/environments/development.rb"
+        say 'Enabled bullet in config/environments/development.rb'
       end
 
       def enable_in_test
-        if yes?("Would you like to enable bullet in test environment? (y/n)")
-          environment(nil, env: "test") do
+        if yes?('Would you like to enable bullet in test environment? (y/n)')
+          environment(nil, env: 'test') do
             <<-"FILE".strip
 
   config.after_initialize do
@@ -38,7 +38,7 @@ Description:
             FILE
           end
 
-          say "Enabled bullet in config/environments/test.rb"
+          say 'Enabled bullet in config/environments/test.rb'
         end
       end
     end

data/perf/benchmark.rb

@@ -53,7 +53,7 @@ end
 
 users_size = 100
 posts_size = 1000
-comments_size = 10000
+comments_size = 10_000
 users = []
 users_size.times do |i|
   users << User.new(:name => "user#{i}")
@@ -63,19 +63,18 @@ users = User.all
 
 posts = []
 posts_size.times do |i|
-  posts << Post.new(:title => "Title #{i}", :body => "Body #{i}", :user => users[i%100])
+  posts << Post.new(:title => "Title #{i}", :body => "Body #{i}", :user => users[i % 100])
 end
 Post.import posts
 posts = Post.all
 
 comments = []
 comments_size.times do |i|
-  comments << Comment.new(:body => "Comment #{i}", :post => posts[i%1000], :user => users[i%100])
+  comments << Comment.new(:body => "Comment #{i}", :post => posts[i % 1000], :user => users[i % 100])
 end
 Comment.import comments
 
-puts "Start benchmarking..."
-
+puts 'Start benchmarking...'
 
 Bullet.enable = true
 
@@ -83,7 +82,7 @@ Benchmark.bm(70) do |bm|
   bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
     10.times do
       Bullet.start_request
-      Post.select("SQL_NO_CACHE *").includes(:user, :comments => :user).each do |p|
+      Post.select('SQL_NO_CACHE *').includes(:user, :comments => :user).each do |p|
         p.title
         p.user.name
         p.comments.each do |c|
@@ -96,8 +95,7 @@ Benchmark.bm(70) do |bm|
   end
 end
 
-puts "End benchmarking..."
-
+puts 'End benchmarking...'
 
 # Run benchmark with bundler
 #

data/spec/bullet/detector/association_spec.rb

@@ -8,15 +8,15 @@ module Bullet
         @post2 = Post.last
       end
 
-      context ".add_object_association" do
-        it "should add object, associations pair" do
+      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_key, :associations)
         end
       end
 
-      context ".add_call_object_associations" do
-        it "should add call object, associations pair" do
+      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_key, :associations)
         end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -8,44 +8,44 @@ module Bullet
         @post2 = Post.last
       end
 
-      context ".add_counter_cache" do
-        it "should create notification if conditions met" do
+      context '.add_counter_cache' do
+        it 'should create notification if conditions met' do
           expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(true)
-          expect(CounterCache).to receive(:create_notification).with("Post", [:comments])
+          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
+        it 'should not create notification if conditions not met' do
           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
       end
 
-      context ".add_possible_objects" do
-        it "should add possible objects" do
+      context '.add_possible_objects' do
+        it 'should add possible objects' do
           CounterCache.add_possible_objects([@post1, @post2])
           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
+        it 'should add impossible object' do
           CounterCache.add_impossible_object(@post1)
           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
+      context '.conditions_met?' do
+        it 'should be true when object is possible, not impossible' do
           CounterCache.add_possible_objects(@post1)
           expect(CounterCache.conditions_met?(@post1, :associations)).to eq true
         end
 
-        it "should be false when object is not possible" do
+        it 'should be false when object is not possible' do
           expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
 
-        it "should be true when object is possible, and impossible" do
+        it 'should be true when object is possible, and impossible' do
           CounterCache.add_possible_objects(@post1)
           CounterCache.add_impossible_object(@post1)
           expect(CounterCache.conditions_met?(@post1, :associations)).to eq false

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -8,62 +8,62 @@ module Bullet
         @post2 = Post.last
       end
 
-      context ".call_association" do
-        it "should add call_object_associations" do
+      context '.call_association' do
+        it 'should add call_object_associations' do
           expect(NPlusOneQuery).to receive(:add_call_object_associations).with(@post, :associations)
           NPlusOneQuery.call_association(@post, :associations)
         end
       end
 
-      context ".possible?" do
-        it "should be true if possible_objects contain" do
+      context '.possible?' do
+        it 'should be true if possible_objects contain' do
           NPlusOneQuery.add_possible_objects(@post)
           expect(NPlusOneQuery.possible?(@post)).to eq true
         end
       end
 
-      context ".impossible?" do
-        it "should be true if impossible_objects contain" do
+      context '.impossible?' do
+        it 'should be true if impossible_objects contain' do
           NPlusOneQuery.add_impossible_object(@post)
           expect(NPlusOneQuery.impossible?(@post)).to eq true
         end
       end
 
-      context ".association?" do
-        it "should be true if object, associations pair is already existed" do
+      context '.association?' do
+        it 'should be true if object, associations pair is already existed' do
           NPlusOneQuery.add_object_associations(@post, :association)
           expect(NPlusOneQuery.association?(@post, :association)).to eq true
         end
 
-        it "should be false if object, association pair is not existed" do
+        it 'should be false if object, association pair is not existed' do
           NPlusOneQuery.add_object_associations(@post, :association1)
           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
+      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).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
+        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).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
+        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).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
+        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).and_return(true)
           allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
           allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(true)
@@ -71,26 +71,26 @@ module Bullet
         end
       end
 
-      context ".call_association" do
-        it "should create notification if conditions met" do
+      context '.call_association' do
+        it 'should create notification if conditions met' do
           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)
+          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
+        it 'should not create notification if conditions not met' do
           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)
+          expect(NPlusOneQuery).not_to receive(:create_notification).with('Post', :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
-        context "stacktrace_excludes" do
-          before { Bullet.stacktrace_excludes = [ /def/ ] }
+        context 'stacktrace_excludes' do
+          before { Bullet.stacktrace_excludes = [/def/] }
           after { Bullet.stacktrace_excludes = nil }
 
-          it "should not create notification when stacktrace contains paths that are in the exclude list" do
+          it 'should not create notification when stacktrace contains paths that are in the exclude list' do
             in_project = OpenStruct.new(:absolute_path => File.join(Dir.pwd, 'abc', 'abc.rb'))
             included_path = OpenStruct.new(:absolute_path => '/ghi/ghi.rb')
             excluded_path = OpenStruct.new(:absolute_path => '/def/def.rb')
@@ -102,48 +102,48 @@ module Bullet
         end
       end
 
-      context ".caller_in_project" do
-        it "should include only paths that are in the project" do
+      context '.caller_in_project' do
+        it 'should include only paths that are in the project' do
           in_project = OpenStruct.new(:absolute_path => File.join(Dir.pwd, 'abc', 'abc.rb'))
           not_in_project = OpenStruct.new(:absolute_path => '/def/def.rb')
 
           expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, not_in_project])
           expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
-          expect(NPlusOneQuery).to receive(:create_notification).with([in_project], "Post", :association)
+          expect(NPlusOneQuery).to receive(:create_notification).with([in_project], 'Post', :association)
           NPlusOneQuery.call_association(@post, :association)
         end
 
-        context "stacktrace_includes" do
-          before { Bullet.stacktrace_includes = [ 'def', /xyz/ ] }
+        context 'stacktrace_includes' do
+          before { Bullet.stacktrace_includes = ['def', /xyz/] }
           after { Bullet.stacktrace_includes = nil }
 
-          it "should include paths that are in the stacktrace_include list" do
+          it 'should include paths that are in the stacktrace_include list' do
             in_project = OpenStruct.new(:absolute_path => File.join(Dir.pwd, 'abc', 'abc.rb'))
             included_gems = [OpenStruct.new(:absolute_path => '/def/def.rb'), OpenStruct.new(:absolute_path => 'xyz/xyz.rb')]
             excluded_gem = OpenStruct.new(:absolute_path => '/ghi/ghi.rb')
 
             expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, *included_gems, excluded_gem])
             expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
-            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, *included_gems], "Post", :association)
+            expect(NPlusOneQuery).to receive(:create_notification).with([in_project, *included_gems], 'Post', :association)
             NPlusOneQuery.call_association(@post, :association)
           end
         end
       end
 
-      context ".add_possible_objects" do
-        it "should add possible objects" do
+      context '.add_possible_objects' do
+        it 'should add possible objects' do
           NPlusOneQuery.add_possible_objects([@post, @post2])
           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
+        it 'should not raise error if object is nil' do
           expect { NPlusOneQuery.add_possible_objects(nil) }.not_to raise_error
         end
       end
 
-      context ".add_impossible_object" do
-        it "should add impossible object" do
+      context '.add_impossible_object' do
+        it 'should add impossible object' do
           NPlusOneQuery.add_impossible_object(@post)
           expect(NPlusOneQuery.impossible_objects).to be_include(@post.bullet_key)
         end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -9,68 +9,68 @@ module Bullet
         @post3 = Post.last
       end
 
-      context ".call_associations" do
-        it "should get empty array if eager_loadings" do
+      context '.call_associations' do
+        it 'should get empty array if eager_loadings' do
           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
+        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_key, Set.new([:association]))).to eq([:association])
         end
 
-        it "should not get call associations if not exist in call_object_associations" do
+        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_key, Set.new([:association]))).to be_empty
         end
       end
 
-      context ".diff_object_associations" do
-        it "should return associations not exist in call_association" do
+      context '.diff_object_associations' do
+        it 'should return associations not exist in call_association' do
           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
+        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_key, Set.new([:association]))).to be_empty
         end
       end
 
-      context ".check_unused_preload_associations" do
-        let(:paths) { ["/dir1", "/dir1/subdir"] }
-        it "should create notification if object_association_diff is not empty" do
+      context '.check_unused_preload_associations' do
+        let(:paths) { ['/dir1', '/dir1/subdir'] }
+        it 'should create notification if object_association_diff is not empty' do
           UnusedEagerLoading.add_object_associations(@post, :association)
           allow(UnusedEagerLoading).to receive(:caller_in_project).and_return(paths)
-          expect(UnusedEagerLoading).to receive(:create_notification).with(paths, "Post", [:association])
+          expect(UnusedEagerLoading).to receive(:create_notification).with(paths, 'Post', [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
 
-        it "should not create notification if object_association_diff is empty" do
+        it 'should not create notification if object_association_diff is empty' do
           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_key, Set.new([:association]))).to be_empty
-          expect(UnusedEagerLoading).not_to receive(:create_notification).with("Post", [:association])
+          expect(UnusedEagerLoading).not_to receive(:create_notification).with('Post', [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
       end
 
-      context ".add_eager_loadings" do
-        it "should add objects, associations pair when eager_loadings are empty" do
+      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_key, @post2.bullet_key], :associations)
         end
 
-        it "should add objects, associations pair for existing eager_loadings" do
+        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_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
+        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_key], :association1)
@@ -78,7 +78,7 @@ module Bullet
           expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association2)
         end
 
-        it "should vmerge objects recursively, associations pair for existing eager_loadings" do
+        it 'should vmerge objects recursively, associations pair for existing eager_loadings' do
           UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
           UnusedEagerLoading.add_eager_loadings([@post, @post3], :association1)
           UnusedEagerLoading.add_eager_loadings([@post, @post3], :association2)
@@ -89,7 +89,7 @@ module Bullet
           expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post3.bullet_key], :association2)
         end
 
-        it "should delete objects, associations pair for existing eager_loadings" do
+        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_key], :association1)

data/spec/bullet/ext/object_spec.rb

@@ -1,34 +1,34 @@
 require 'spec_helper'
 
 describe Object do
-  context "bullet_key" do
-    it "should return class and id composition" do
+  context 'bullet_key' do
+    it 'should return class and id composition' do
       post = Post.first
       expect(post.bullet_key).to eq("Post:#{post.id}")
     end
 
     if mongoid?
-      it "should return class with namesapce and id composition" do
+      it 'should return class with namesapce and id composition' do
         post = Mongoid::Post.first
         expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
       end
     end
   end
 
-  context "primary_key_value" do
-    it "should return id" do
+  context 'primary_key_value' do
+    it 'should return id' do
       post = Post.first
       expect(post.primary_key_value).to eq(post.id)
     end
 
-    it "should return primary key value" do
+    it 'should return primary key value' do
       post = Post.first
       Post.primary_key = 'name'
       expect(post.primary_key_value).to eq(post.name)
       Post.primary_key = 'id'
     end
 
-    it "should return value for multiple primary keys" do
+    it 'should return value for multiple primary keys' do
       post = Post.first
       allow(Post).to receive(:primary_keys).and_return([:category_id, :writer_id])
       expect(post.primary_key_value).to eq("#{post.category_id},#{post.writer_id}")

data/spec/bullet/ext/string_spec.rb

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