bullet 5.6.0 → 5.6.1

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
+        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
+        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

data/spec/bullet/notification/base_spec.rb

@@ -5,41 +5,41 @@ module Bullet
     describe Base do
       subject { Base.new(Post, [:comments, :votes]) }
 
-      context "#title" do
-        it "should raise NoMethodError" do
+      context '#title' do
+        it 'should raise NoMethodError' do
           expect { subject.title }.to raise_error(NoMethodError)
         end
       end
 
-      context "#body" do
-        it "should raise NoMethodError" do
+      context '#body' do
+        it 'should raise NoMethodError' do
           expect { subject.body }.to raise_error(NoMethodError)
         end
       end
 
-      context "#whoami" do
-        it "should display user name" do
+      context '#whoami' do
+        it 'should display user name' do
           user = `whoami`.chomp
           expect(subject.whoami).to eq("user: #{user}")
         end
 
-        it "should leverage ENV parameter" do
-          temp_env_variable("USER", "bogus") do
-            expect(subject.whoami).to eq("user: bogus")
+        it 'should leverage ENV parameter' do
+          temp_env_variable('USER', 'bogus') do
+            expect(subject.whoami).to eq('user: bogus')
           end
         end
 
-        it "should return blank if no user available" do
-          temp_env_variable("USER", "") do
-            expect(subject).to receive(:`).with("whoami").and_return("")
-            expect(subject.whoami).to eq("")
+        it 'should return blank if no user available' do
+          temp_env_variable('USER', '') do
+            expect(subject).to receive(:`).with('whoami').and_return('')
+            expect(subject.whoami).to eq('')
           end
         end
 
-        it "should return blank if whoami is not available" do
-          temp_env_variable("USER", "") do
-            expect(subject).to receive(:`).with("whoami").and_raise(Errno::ENOENT)
-            expect(subject.whoami).to eq("")
+        it 'should return blank if whoami is not available' do
+          temp_env_variable('USER', '') do
+            expect(subject).to receive(:`).with('whoami').and_raise(Errno::ENOENT)
+            expect(subject.whoami).to eq('')
           end
         end
 
@@ -53,26 +53,26 @@ module Bullet
 
       end
 
-      context "#body_with_caller" do
-        it "should return body" do
-          allow(subject).to receive(:body).and_return("body")
-          allow(subject).to receive(:call_stack_messages).and_return("call_stack_messages")
+      context '#body_with_caller' do
+        it 'should return body' do
+          allow(subject).to receive(:body).and_return('body')
+          allow(subject).to receive(:call_stack_messages).and_return('call_stack_messages')
           expect(subject.body_with_caller).to eq("body\ncall_stack_messages\n")
         end
       end
 
-      context "#notification_data" do
-        it "should return notification data" do
-          allow(subject).to receive(:whoami).and_return("whoami")
-          allow(subject).to receive(:url).and_return("url")
-          allow(subject).to receive(:title).and_return("title")
-          allow(subject).to receive(:body_with_caller).and_return("body_with_caller")
-          expect(subject.notification_data).to eq(:user => "whoami", :url => "url", :title => "title", :body => "body_with_caller")
+      context '#notification_data' do
+        it 'should return notification data' do
+          allow(subject).to receive(:whoami).and_return('whoami')
+          allow(subject).to receive(:url).and_return('url')
+          allow(subject).to receive(:title).and_return('title')
+          allow(subject).to receive(:body_with_caller).and_return('body_with_caller')
+          expect(subject.notification_data).to eq(:user => 'whoami', :url => 'url', :title => 'title', :body => 'body_with_caller')
         end
       end
 
-      context "#notify_inline" do
-        it "should send full_notice to notifier" do
+      context '#notify_inline' do
+        it 'should send full_notice to notifier' do
           notifier = double
           allow(subject).to receive(:notifier).and_return(notifier)
           allow(subject).to receive(:notification_data).and_return(:foo => :bar)
@@ -81,8 +81,8 @@ module Bullet
         end
       end
 
-      context "#notify_out_of_channel" do
-        it "should send full_out_of_channel to notifier" do
+      context '#notify_out_of_channel' do
+        it 'should send full_out_of_channel to notifier' do
           notifier = double
           allow(subject).to receive(:notifier).and_return(notifier)
           allow(subject).to receive(:notification_data).and_return(:foo => :bar)