bullet 6.1.0 → 7.0.0

data/lib/bullet.rb

@@ -20,9 +20,6 @@ module Bullet
   autoload :Registry, 'bullet/registry'
   autoload :NotificationCollector, 'bullet/notification_collector'
 
-  BULLET_DEBUG = 'BULLET_DEBUG'
-  TRUE = 'true'
-
   if defined?(Rails::Railtie)
     class BulletRailtie < Rails::Railtie
       initializer 'bullet.configure_rails_initialization' do |app|
@@ -38,10 +35,11 @@ module Bullet
                 :stacktrace_includes,
                 :stacktrace_excludes,
                 :skip_html_injection
-    attr_reader :whitelist
-    attr_accessor :add_footer, :orm_patches_applied
+    attr_reader :safelist
+    attr_accessor :add_footer, :orm_patches_applied, :skip_http_headers
 
-    available_notifiers = UniformNotifier::AVAILABLE_NOTIFIERS.map { |notifier| "#{notifier}=" }
+    available_notifiers =
+      UniformNotifier::AVAILABLE_NOTIFIERS.select { |notifier| notifier != :raise }.map { |notifier| "#{notifier}=" }
     available_notifiers_options = { to: UniformNotifier }
     delegate(*available_notifiers, **available_notifiers_options)
 
@@ -59,7 +57,7 @@ module Bullet
       @enable = @n_plus_one_query_enable = @unused_eager_loading_enable = @counter_cache_enable = enable
 
       if enable?
-        reset_whitelist
+        reset_safelist
         unless orm_patches_applied
           self.orm_patches_applied = true
           Bullet::Mongoid.enable if mongoid?
@@ -72,8 +70,9 @@ module Bullet
       !!@enable
     end
 
+    # Rails.root might be nil if `railties` is a dependency on a project that does not use Rails
     def app_root
-      (defined?(::Rails.root) ? Rails.root.to_s : Dir.pwd).to_s
+      @app_root ||= (defined?(::Rails.root) && !::Rails.root.nil? ? Rails.root.to_s : Dir.pwd).to_s
     end
 
     def n_plus_one_query_enable?
@@ -89,36 +88,81 @@ module Bullet
     end
 
     def stacktrace_includes
-      @stacktrace_includes || []
+      @stacktrace_includes ||= []
     end
 
     def stacktrace_excludes
-      @stacktrace_excludes || []
+      @stacktrace_excludes ||= []
+    end
+
+    def add_safelist(options)
+      reset_safelist
+      @safelist[options[:type]][options[:class_name]] ||= []
+      @safelist[options[:type]][options[:class_name]] << options[:association].to_sym
+    end
+
+    def delete_safelist(options)
+      reset_safelist
+      @safelist[options[:type]][options[:class_name]] ||= []
+      @safelist[options[:type]][options[:class_name]].delete(options[:association].to_sym)
+      @safelist[options[:type]].delete_if { |_key, val| val.empty? }
+    end
+
+    def get_safelist_associations(type, class_name)
+      Array(@safelist[type][class_name])
+    end
+
+    def reset_safelist
+      @safelist ||= { n_plus_one_query: {}, unused_eager_loading: {}, counter_cache: {} }
+    end
+
+    def clear_safelist
+      @safelist = nil
     end
 
     def add_whitelist(options)
-      reset_whitelist
-      @whitelist[options[:type]][options[:class_name]] ||= []
-      @whitelist[options[:type]][options[:class_name]] << options[:association].to_sym
+      ActiveSupport::Deprecation.warn(<<~WARN.strip
+        add_whitelist is deprecated in favor of add_safelist. It will be removed from the next major release.
+        WARN
+      )
+
+      add_safelist(options)
     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? }
+      ActiveSupport::Deprecation.warn(<<~WARN.strip
+        delete_whitelist is deprecated in favor of delete_safelist. It will be removed from the next major release.
+        WARN
+      )
+
+      delete_safelist(options)
     end
 
     def get_whitelist_associations(type, class_name)
-      Array(@whitelist[type][class_name])
+      ActiveSupport::Deprecation.warn(<<~WARN.strip
+        get_whitelist_associations is deprecated in favor of get_safelist_associations. It will be removed from the next major release.
+        WARN
+      )
+
+      get_safelist_associations(type, class_name)
     end
 
     def reset_whitelist
-      @whitelist ||= { n_plus_one_query: {}, unused_eager_loading: {}, counter_cache: {} }
+      ActiveSupport::Deprecation.warn(<<~WARN.strip
+        reset_whitelist is deprecated in favor of reset_safelist. It will be removed from the next major release.
+        WARN
+      )
+
+      reset_safelist
     end
 
     def clear_whitelist
-      @whitelist = nil
+      ActiveSupport::Deprecation.warn(<<~WARN.strip
+        clear_whitelist is deprecated in favor of clear_safelist. It will be removed from the next major release.
+        WARN
+      )
+
+      clear_safelist
     end
 
     def bullet_logger=(active)
@@ -132,7 +176,7 @@ module Bullet
     end
 
     def debug(title, message)
-      puts "[Bullet][#{title}] #{message}" if ENV[BULLET_DEBUG] == TRUE
+      puts "[Bullet][#{title}] #{message}" if ENV['BULLET_DEBUG'] == 'true'
     end
 
     def start_request
@@ -240,8 +284,10 @@ module Bullet
       UniformNotifier.active_notifiers.include?(UniformNotifier::JavascriptConsole)
     end
 
-    def skip_html_injection?
-      @skip_html_injection || false
+    def inject_into_page?
+      return false if defined?(@skip_html_injection) && @skip_html_injection
+
+      console_enabled? || add_footer
     end
 
     private

data/lib/generators/bullet/install_generator.rb

@@ -10,40 +10,38 @@ module Bullet
 
       def enable_in_development
         environment(nil, env: 'development') do
-          <<-"FILE"
-
-  config.after_initialize do
-    Bullet.enable        = true
-    Bullet.alert         = true
-    Bullet.bullet_logger = true
-    Bullet.console       = true
-  # Bullet.growl         = true
-    Bullet.rails_logger  = true
-    Bullet.add_footer    = true
-  end
+          <<~FILE
+            config.after_initialize do
+              Bullet.enable        = true
+              Bullet.alert         = true
+              Bullet.bullet_logger = true
+              Bullet.console       = true
+            # Bullet.growl         = true
+              Bullet.rails_logger  = true
+              Bullet.add_footer    = true
+            end
+
           FILE
-            .strip
         end
 
         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
-            <<-"FILE"
-
-  config.after_initialize do
-    Bullet.enable        = true
-    Bullet.bullet_logger = true
-    Bullet.raise         = true # raise an error if n+1 query occurs
-  end
-            FILE
-              .strip
-          end
+        return unless yes?('Would you like to enable bullet in test environment? (y/n)')
 
-          say 'Enabled bullet in config/environments/test.rb'
+        environment(nil, env: 'test') do
+          <<~FILE
+            config.after_initialize do
+              Bullet.enable        = true
+              Bullet.bullet_logger = true
+              Bullet.raise         = true # raise an error if n+1 query occurs
+            end
+
+          FILE
         end
+
+        say 'Enabled bullet in config/environments/test.rb'
       end
     end
   end

data/perf/benchmark.rb

@@ -30,7 +30,10 @@ end
 
 # create database bullet_benchmark;
 ActiveRecord::Base.establish_connection(
-  adapter: 'mysql2', database: 'bullet_benchmark', server: '/tmp/mysql.socket', username: 'root'
+  adapter: 'mysql2',
+  database: 'bullet_benchmark',
+  server: '/tmp/mysql.socket',
+  username: 'root'
 )
 
 ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }

data/spec/bullet/detector/counter_cache_spec.rb

@@ -47,7 +47,7 @@ module Bullet
           expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
         end
 
-        it 'should be true when object is possible, and impossible' do
+        it 'should be false 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/unused_eager_loading_spec.rb

@@ -13,27 +13,27 @@ module Bullet
 
       context '.call_associations' do
         it 'should get empty array if eager_loadings' do
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new(%i[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_key, Set.new(%i[association]))).to eq(
-            %i[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_key, Set.new(%i[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_key, Set.new(%i[association]))).to eq(
-            %i[association]
+          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to eq(
+            [:association]
           )
         end
 
@@ -41,7 +41,7 @@ module Bullet
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
           expect(
-            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new(%i[association]))
+            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))
           ).to be_empty
         end
       end
@@ -51,7 +51,7 @@ module Bullet
         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', %i[association])
+          expect(UnusedEagerLoading).to receive(:create_notification).with(paths, 'Post', [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
 
@@ -60,9 +60,9 @@ module Bullet
           UnusedEagerLoading.add_eager_loadings([@post], :association)
           UnusedEagerLoading.add_call_object_associations(@post, :association)
           expect(
-            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new(%i[association]))
+            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))
           ).to be_empty
-          expect(UnusedEagerLoading).not_to receive(:create_notification).with('Post', %i[association])
+          expect(UnusedEagerLoading).not_to receive(:create_notification).with('Post', [:association])
           UnusedEagerLoading.check_unused_preload_associations
         end
       end

data/spec/bullet/ext/object_spec.rb

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

data/spec/bullet/notification/n_plus_one_query_spec.rb

@@ -21,9 +21,7 @@ module Bullet
         )
       end
       it do
-        expect(subject.body).to eq(
-          "  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])"
-        )
+        expect(subject.body).to eq("  Post => [:comments, :votes]\n  Add to your query: .includes([:comments, :votes])")
       end
       it { expect(subject.title).to eq('USE eager loading in path') }
     end

data/spec/bullet/rack_spec.rb

@@ -67,9 +67,8 @@ module Bullet
 
         it 'should change response body if notification is active' do
           expect(Bullet).to receive(:notification?).and_return(true)
-          allow(Bullet).to receive(:skip_html_injection?).and_return(false)
+          expect(Bullet).to receive(:console_enabled?).and_return(true)
           expect(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
-          expect(middleware).to receive(:xhr_script).and_return('')
           expect(Bullet).to receive(:perform_out_of_channel_notifications)
           _, headers, response = middleware.call('Content-Type' => 'text/html')
           expect(headers['Content-Length']).to eq('56')
@@ -81,9 +80,123 @@ module Bullet
           response.body = '<html><head></head><body>é</body></html>'
           app.response = response
           expect(Bullet).to receive(:notification?).and_return(true)
+          allow(Bullet).to receive(:console_enabled?).and_return(true)
           expect(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
           _, headers, response = middleware.call('Content-Type' => 'text/html')
-          expect(headers['Content-Length']).to eq((58 + middleware.send(:xhr_script).length).to_s)
+          expect(headers['Content-Length']).to eq('58')
+        end
+
+        context 'with injection notifiers' do
+          before do
+            expect(Bullet).to receive(:notification?).and_return(true)
+            allow(Bullet).to receive(:gather_inline_notifications).and_return('<bullet></bullet>')
+            allow(middleware).to receive(:xhr_script).and_return('<script></script>')
+            allow(middleware).to receive(:footer_note).and_return('footer')
+            expect(Bullet).to receive(:perform_out_of_channel_notifications)
+          end
+
+          it 'should change response body if add_footer is true' do
+            expect(Bullet).to receive(:add_footer).exactly(3).times.and_return(true)
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+
+            expect(headers['Content-Length']).to eq((73 + middleware.send(:footer_note).length).to_s)
+            expect(response).to eq(%w[<html><head></head><body>footer<bullet></bullet><script></script></body></html>])
+          end
+
+          it 'should change response body for html safe string if add_footer is true' do
+            expect(Bullet).to receive(:add_footer).exactly(3).times.and_return(true)
+            app.response =
+              Support::ResponseDouble.new.tap do |response|
+                response.body = ActiveSupport::SafeBuffer.new('<html><head></head><body></body></html>')
+              end
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+
+            expect(headers['Content-Length']).to eq((73 + middleware.send(:footer_note).length).to_s)
+            expect(response).to eq(%w[<html><head></head><body>footer<bullet></bullet><script></script></body></html>])
+          end
+
+          it 'should add the footer-text header for non-html requests when add_footer is true' do
+            allow(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+            allow(Bullet).to receive(:footer_info).and_return(['footer text'])
+            app.headers = { 'Content-Type' => 'application/json' }
+            _, headers, _response = middleware.call({})
+            expect(headers).to include('X-bullet-footer-text' => '["footer text"]')
+          end
+
+          it 'should change response body if console_enabled is true' do
+            expect(Bullet).to receive(:console_enabled?).and_return(true)
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+            expect(headers['Content-Length']).to eq('56')
+            expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
+          end
+
+          it 'should change response body for html safe string if console_enabled is true' do
+            expect(Bullet).to receive(:console_enabled?).and_return(true)
+            app.response =
+              Support::ResponseDouble.new.tap do |response|
+                response.body = ActiveSupport::SafeBuffer.new('<html><head></head><body></body></html>')
+              end
+            _, headers, response = middleware.call('Content-Type' => 'text/html')
+            expect(headers['Content-Length']).to eq('56')
+            expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
+          end
+
+          it 'should add headers for non-html requests when console_enabled is true' do
+            allow(Bullet).to receive(:console_enabled?).at_least(:once).and_return(true)
+            allow(Bullet).to receive(:text_notifications).and_return(['text notifications'])
+            app.headers = { 'Content-Type' => 'application/json' }
+            _, headers, _response = middleware.call({})
+            expect(headers).to include('X-bullet-console-text' => '["text notifications"]')
+          end
+
+          it "shouldn't change response body unnecessarily" do
+            expected_response = Support::ResponseDouble.new 'Actual body'
+            app.response = expected_response
+            _, _, response = middleware.call({})
+            expect(response).to eq(expected_response)
+          end
+
+          it "shouldn't add headers unnecessarily" do
+            app.headers = { 'Content-Type' => 'application/json' }
+            _, headers, _response = middleware.call({})
+            expect(headers).not_to include('X-bullet-footer-text')
+            expect(headers).not_to include('X-bullet-console-text')
+          end
+
+          context 'when skip_http_headers is enabled' do
+            before do
+              allow(Bullet).to receive(:skip_http_headers).and_return(true)
+            end
+
+            it 'should include the footer but not the xhr script tag if add_footer is true' do
+              expect(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+              _, headers, response = middleware.call({})
+
+              expect(headers['Content-Length']).to eq((56 + middleware.send(:footer_note).length).to_s)
+              expect(response).to eq(%w[<html><head></head><body>footer<bullet></bullet></body></html>])
+            end
+
+            it 'should not include the xhr script tag if console_enabled is true' do
+              expect(Bullet).to receive(:console_enabled?).and_return(true)
+              _, headers, response = middleware.call({})
+              expect(headers['Content-Length']).to eq('56')
+              expect(response).to eq(%w[<html><head></head><body><bullet></bullet></body></html>])
+            end
+
+            it 'should not add the footer-text header for non-html requests when add_footer is true' do
+              allow(Bullet).to receive(:add_footer).at_least(:once).and_return(true)
+              app.headers = { 'Content-Type' => 'application/json' }
+              _, headers, _response = middleware.call({})
+              expect(headers).not_to include('X-bullet-footer-text')
+            end
+
+            it 'should not add headers for non-html requests when console_enabled is true' do
+              allow(Bullet).to receive(:console_enabled?).at_least(:once).and_return(true)
+              app.headers = { 'Content-Type' => 'application/json' }
+              _, headers, _response = middleware.call({})
+              expect(headers).not_to include('X-bullet-console-text')
+            end
+          end
         end
 
         context 'when skip_html_injection is enabled' do
@@ -148,6 +261,20 @@ module Bullet
           expect(middleware.response_body(response)).to eq body_string
         end
       end
+
+      begin
+        require 'rack/files'
+
+        context 'when `response` is a Rack::Files::Iterator' do
+          let(:response) { instance_double(::Rack::Files::Iterator) }
+          before { allow(response).to receive(:is_a?).with(::Rack::Files::Iterator) { true } }
+
+          it 'should return nil' do
+            expect(middleware.response_body(response)).to be_nil
+          end
+        end
+      rescue LoadError
+      end
     end
   end
 end

data/spec/bullet_spec.rb

@@ -74,31 +74,60 @@ describe Bullet, focused: true do
     end
   end
 
+  describe '#add_safelist' do
+    context "for 'special' class names" do
+      it 'is added to the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to include :department
+      end
+    end
+  end
+
   describe '#add_whitelist' do
     context "for 'special' class names" do
-      it 'is added to the whitelist successfully' do
+      it 'is added to the safelist successfully' do
         Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        expect(Bullet.get_whitelist_associations(:n_plus_one_query, 'Klass')).to include :department
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to include :department
+      end
+    end
+  end
+
+  describe '#delete_safelist' do
+    context "for 'special' class names" do
+      it 'is deleted from the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        Bullet.delete_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        expect(Bullet.safelist[:n_plus_one_query]).to eq({})
+      end
+    end
+
+    context 'when exists multiple definitions' do
+      it 'is deleted from the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
+        Bullet.delete_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to include :department
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to_not include :team
       end
     end
   end
 
   describe '#delete_whitelist' do
     context "for 'special' class names" do
-      it 'is deleted from the whitelist successfully' do
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+      it 'is deleted from the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
         Bullet.delete_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        expect(Bullet.whitelist[:n_plus_one_query]).to eq({})
+        expect(Bullet.safelist[:n_plus_one_query]).to eq({})
       end
     end
 
     context 'when exists multiple definitions' do
-      it 'is deleted from the whitelist successfully' do
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
-        Bullet.add_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
+      it 'is deleted from the safelist successfully' do
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :department)
+        Bullet.add_safelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
         Bullet.delete_whitelist(type: :n_plus_one_query, class_name: 'Klass', association: :team)
-        expect(Bullet.get_whitelist_associations(:n_plus_one_query, 'Klass')).to include :department
-        expect(Bullet.get_whitelist_associations(:n_plus_one_query, 'Klass')).to_not include :team
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to include :department
+        expect(Bullet.get_safelist_associations(:n_plus_one_query, 'Klass')).to_not include :team
       end
     end
   end