bullet 5.5.0 → 6.1.5

data/lib/bullet.rb

@@ -1,4 +1,6 @@
-require "active_support/core_ext/module/delegation"
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
 require 'set'
 require 'uniform_notifier'
 require 'bullet/ext/object'
@@ -12,45 +14,52 @@ module Bullet
   autoload :ActiveRecord, "bullet/#{active_record_version}" if active_record?
   autoload :Mongoid, "bullet/#{mongoid_version}" if mongoid?
   autoload :Rack, 'bullet/rack'
+  autoload :ActiveJob, 'bullet/active_job'
   autoload :Notification, 'bullet/notification'
   autoload :Detector, 'bullet/detector'
   autoload :Registry, 'bullet/registry'
   autoload :NotificationCollector, 'bullet/notification_collector'
 
-  BULLET_DEBUG = 'BULLET_DEBUG'.freeze
-  TRUE = 'true'.freeze
-
-  if defined? Rails::Railtie
+  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
   end
 
   class << self
-    attr_writer :enable, :n_plus_one_query_enable, :unused_eager_loading_enable, :counter_cache_enable, :stacktrace_includes, :stacktrace_excludes
-    attr_reader :notification_collector, :whitelist
-    attr_accessor :add_footer, :orm_pathches_applied
-
-    available_notifiers = UniformNotifier::AVAILABLE_NOTIFIERS.map { |notifier| "#{notifier}=" }
-    available_notifiers << { :to => UniformNotifier }
-    delegate *available_notifiers
+    attr_writer :n_plus_one_query_enable,
+                :unused_eager_loading_enable,
+                :counter_cache_enable,
+                :stacktrace_includes,
+                :stacktrace_excludes,
+                :skip_html_injection
+    attr_reader :safelist
+    attr_accessor :add_footer, :orm_patches_applied, :skip_http_headers
+
+    available_notifiers =
+      UniformNotifier::AVAILABLE_NOTIFIERS.select { |notifier| notifier != :raise }.map { |notifier| "#{notifier}=" }
+    available_notifiers_options = { to: UniformNotifier }
+    delegate(*available_notifiers, **available_notifiers_options)
 
     def raise=(should_raise)
-      UniformNotifier.raise=(should_raise ? Notification::UnoptimizedQueryError : false)
+      UniformNotifier.raise = (should_raise ? Notification::UnoptimizedQueryError : false)
     end
 
-    DETECTORS = [ Bullet::Detector::NPlusOneQuery,
-                  Bullet::Detector::UnusedEagerLoading,
-                  Bullet::Detector::CounterCache ]
+    DETECTORS = [
+      Bullet::Detector::NPlusOneQuery,
+      Bullet::Detector::UnusedEagerLoading,
+      Bullet::Detector::CounterCache
+    ].freeze
 
     def enable=(enable)
       @enable = @n_plus_one_query_enable = @unused_eager_loading_enable = @counter_cache_enable = enable
+
       if enable?
-        reset_whitelist
-        unless orm_pathches_applied
-          self.orm_pathches_applied = true
+        reset_safelist
+        unless orm_patches_applied
+          self.orm_patches_applied = true
           Bullet::Mongoid.enable if mongoid?
           Bullet::ActiveRecord.enable if active_record?
         end
@@ -61,57 +70,113 @@ 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
+      @app_root ||= (defined?(::Rails.root) && !::Rails.root.nil? ? Rails.root.to_s : Dir.pwd).to_s
+    end
+
     def n_plus_one_query_enable?
-      self.enable? && !!@n_plus_one_query_enable
+      enable? && !!@n_plus_one_query_enable
     end
 
     def unused_eager_loading_enable?
-      self.enable? && !!@unused_eager_loading_enable
+      enable? && !!@unused_eager_loading_enable
     end
 
     def counter_cache_enable?
-      self.enable? && !!@counter_cache_enable
+      enable? && !!@counter_cache_enable
     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)
+      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)
       if active
         require 'fileutils'
-        root_path = "#{rails? ? Rails.root.to_s : Dir.pwd}"
-        FileUtils.mkdir_p(root_path + '/log')
-        bullet_log_file = File.open("#{root_path}/log/bullet.log", 'a+')
+        FileUtils.mkdir_p(app_root + '/log')
+        bullet_log_file = File.open("#{app_root}/log/bullet.log", 'a+')
         bullet_log_file.sync = true
         UniformNotifier.customized_logger = bullet_log_file
       end
     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
@@ -154,16 +219,15 @@ module Bullet
 
     def notification?
       return unless start?
+
       Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
       notification_collector.notifications_present?
     end
 
     def gather_inline_notifications
       responses = []
-      for_each_active_notifier_with_notification do |notification|
-        responses << notification.notify_inline
-      end
-      responses.join( "\n" )
+      for_each_active_notifier_with_notification { |notification| responses << notification.notify_inline }
+      responses.join("\n")
     end
 
     def perform_out_of_channel_notifications(env = {})
@@ -175,24 +239,30 @@ module Bullet
     end
 
     def footer_info
+      info = []
+      notification_collector.collection.each { |notification| info << notification.short_notice }
+      info
+    end
+
+    def text_notifications
       info = []
       notification_collector.collection.each do |notification|
-        info << notification.short_notice
+        info << notification.notification_data.values.compact.join("\n")
       end
       info
     end
 
     def warnings
-      notification_collector.collection.inject({}) do |warnings, notification|
+      notification_collector.collection.each_with_object({}) do |notification, warnings|
         warning_type = notification.class.to_s.split(':').last.tableize
         warnings[warning_type] ||= []
         warnings[warning_type] << notification
-        warnings
       end
     end
 
     def profile
       return_value = nil
+
       if Bullet.enable?
         begin
           Bullet.start_request
@@ -210,24 +280,35 @@ module Bullet
       return_value
     end
 
+    def console_enabled?
+      UniformNotifier.active_notifiers.include?(UniformNotifier::JavascriptConsole)
+    end
+
+    def inject_into_page?
+      return false if defined?(@skip_html_injection) && @skip_html_injection
+
+      console_enabled? || add_footer
+    end
+
     private
-      def for_each_active_notifier_with_notification
-        UniformNotifier.active_notifiers.each do |notifier|
-          notification_collector.collection.each do |notification|
-            notification.notifier = notifier
-            yield notification
-          end
+
+    def for_each_active_notifier_with_notification
+      UniformNotifier.active_notifiers.each do |notifier|
+        notification_collector.collection.each do |notification|
+          notification.notifier = notifier
+          yield notification
         end
       end
+    end
 
-      def build_request_uri(env)
-        return "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']}" if env['REQUEST_URI']
+    def build_request_uri(env)
+      return "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']}" if env['REQUEST_URI']
 
-        if env['QUERY_STRING'].present?
-          "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}?#{env['QUERY_STRING']}"
-        else
-          "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
-        end
+      if env['QUERY_STRING'].present?
+        "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}?#{env['QUERY_STRING']}"
+      else
+        "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
       end
+    end
   end
 end

data/lib/generators/bullet/install_generator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Bullet
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc <<~DESC
+        Description:
+            Enable bullet in development/test for your application.
+      DESC
+
+      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
+        end
+
+        say 'Enabled bullet in config/environments/development.rb'
+      end
+
+      def enable_in_test
+        return unless 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
+        end
+
+        say 'Enabled bullet in config/environments/test.rb'
+      end
+    end
+  end
+end

data/perf/benchmark.rb

@@ -1,4 +1,6 @@
-$: << 'lib'
+# frozen_string_literal: true
+
+$LOAD_PATH << 'lib'
 require 'benchmark'
 require 'rails'
 require 'active_record'
@@ -27,13 +29,16 @@ class User < ActiveRecord::Base
 end
 
 # create database bullet_benchmark;
-ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'bullet_benchmark', :server => '/tmp/mysql.socket', :username => 'root')
+ActiveRecord::Base.establish_connection(
+  adapter: 'mysql2',
+  database: 'bullet_benchmark',
+  server: '/tmp/mysql.socket',
+  username: 'root'
+)
 
-ActiveRecord::Base.connection.tables.each do |table|
-  ActiveRecord::Base.connection.drop_table(table)
-end
+ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
 
-ActiveRecord::Schema.define(:version => 1) do
+ActiveRecord::Schema.define(version: 1) do
   create_table :posts do |t|
     t.column :title, :string
     t.column :body, :string
@@ -52,30 +57,23 @@ ActiveRecord::Schema.define(:version => 1) do
 end
 
 users_size = 100
-posts_size = 1000
-comments_size = 10000
+posts_size = 1_000
+comments_size = 10_000
 users = []
-users_size.times do |i|
-  users << User.new(:name => "user#{i}")
-end
+users_size.times { |i| users << User.new(name: "user#{i}") }
 User.import users
 users = User.all
 
 posts = []
-posts_size.times do |i|
-  posts << Post.new(:title => "Title #{i}", :body => "Body #{i}", :user => users[i%100])
-end
+posts_size.times { |i| posts << Post.new(title: "Title #{i}", body: "Body #{i}", user: users[i % 100]) }
 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])
-end
+comments_size.times { |i| comments << Comment.new(body: "Comment #{i}", post: posts[i % 1_000], user: users[i % 100]) }
 Comment.import comments
 
-puts "Start benchmarking..."
-
+puts 'Start benchmarking...'
 
 Bullet.enable = true
 
@@ -83,7 +81,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 +94,7 @@ Benchmark.bm(70) do |bm|
   end
 end
 
-puts "End benchmarking..."
-
+puts 'End benchmarking...'
 
 # Run benchmark with bundler
 #

data/rails/init.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'bullet'

data/spec/bullet/detector/association_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
@@ -8,15 +10,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/base_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet

data/spec/bullet/detector/counter_cache_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Bullet
@@ -8,44 +10,44 @@ module Bullet
         @post2 = Post.last
       end
 
-      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])
-          CounterCache.add_counter_cache(@post1, [:comments])
+      context '.add_counter_cache' do
+        it 'should create notification if conditions met' do
+          expect(CounterCache).to receive(:conditions_met?).with(@post1, %i[comments]).and_return(true)
+          expect(CounterCache).to receive(:create_notification).with('Post', %i[comments])
+          CounterCache.add_counter_cache(@post1, %i[comments])
         end
 
-        it "should not create notification if conditions not met" do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1, [:comments]).and_return(false)
+        it 'should not create notification if conditions not met' do
+          expect(CounterCache).to receive(:conditions_met?).with(@post1, %i[comments]).and_return(false)
           expect(CounterCache).to receive(:create_notification).never
-          CounterCache.add_counter_cache(@post1, [:comments])
+          CounterCache.add_counter_cache(@post1, %i[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 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