bullet 5.5.0 → 5.8.0

data/lib/bullet/registry/object.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bullet
   module Registry
     class Object < Base

data/lib/bullet/registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bullet
   module Registry
     autoload :Base, 'bullet/registry/base'

data/lib/bullet/stack_trace_filter.rb

@@ -1,34 +1,72 @@
+# frozen_string_literal: true
+
 module Bullet
   module StackTraceFilter
-    VENDOR_PATH = "/vendor"
+    VENDOR_PATH = '/vendor'
 
     def caller_in_project
       app_root = rails? ? Rails.root.to_s : Dir.pwd
       vendor_root = app_root + VENDOR_PATH
-      caller.select do |caller_path|
-        caller_path.include?(app_root) && !caller_path.include?(vendor_root) ||
-          Bullet.stacktrace_includes.any? do |include_pattern|
-          case include_pattern
-          when String
-            caller_path.include?(include_pattern)
-          when Regexp
-            caller_path =~ include_pattern
-          end
-        end
+      bundler_path = Bundler.bundle_path.to_s
+      select_caller_locations do |location|
+        caller_path = location_as_path(location)
+        caller_path.include?(app_root) && !caller_path.include?(vendor_root) && !caller_path.include?(bundler_path) ||
+          Bullet.stacktrace_includes.any? { |include_pattern| pattern_matches?(location, include_pattern) }
       end
     end
 
     def excluded_stacktrace_path?
       Bullet.stacktrace_excludes.any? do |exclude_pattern|
-        caller_in_project.any? do |caller_path|
-          case exclude_pattern
-          when String
-            caller_path.include?(exclude_pattern)
-          when Regexp
-            caller_path =~ exclude_pattern
-          end
+        caller_in_project.any? { |location| pattern_matches?(location, exclude_pattern) }
+      end
+    end
+
+    private
+
+    def pattern_matches?(location, pattern)
+      path = location_as_path(location)
+      case pattern
+      when Array
+        pattern_path = pattern.first
+        filter = pattern.last
+        return false unless pattern_matches?(location, pattern_path)
+
+        case filter
+        when Range
+          filter.include?(location.lineno)
+        when Integer
+          filter == location.lineno
+        when String
+          filter == location.base_label
         end
+      when String
+        path.include?(pattern)
+      when Regexp
+        path =~ pattern
+      end
+    end
+
+    def location_as_path(location)
+      ruby_19? ? location : location.absolute_path.to_s
+    end
+
+    def select_caller_locations
+      if ruby_19?
+        caller.select do |caller_path|
+          yield caller_path
+        end
+      else
+        caller_locations.select do |location|
+          yield location
+        end
+      end
+    end
+
+    def ruby_19?
+      if @ruby_19.nil?
+        @ruby_19 = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
       end
+      @ruby_19
     end
   end
 end

data/lib/bullet/version.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Bullet
-  VERSION = "5.5.0"
+  VERSION = '5.8.0'
 end

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'
@@ -17,33 +19,33 @@ module Bullet
   autoload :Registry, 'bullet/registry'
   autoload :NotificationCollector, 'bullet/notification_collector'
 
-  BULLET_DEBUG = 'BULLET_DEBUG'.freeze
-  TRUE = 'true'.freeze
+  BULLET_DEBUG = 'BULLET_DEBUG'
+  TRUE = 'true'
 
   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_writer :n_plus_one_query_enable, :unused_eager_loading_enable, :counter_cache_enable, :stacktrace_includes, :stacktrace_excludes
+    attr_reader :whitelist
     attr_accessor :add_footer, :orm_pathches_applied
 
     available_notifiers = UniformNotifier::AVAILABLE_NOTIFIERS.map { |notifier| "#{notifier}=" }
-    available_notifiers << { :to => UniformNotifier }
-    delegate *available_notifiers
+    available_notifiers << { to: UniformNotifier }
+    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,
-                  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
@@ -62,15 +64,15 @@ module Bullet
     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
@@ -87,12 +89,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
@@ -102,7 +111,7 @@ module Bullet
     def bullet_logger=(active)
       if active
         require 'fileutils'
-        root_path = "#{rails? ? Rails.root.to_s : Dir.pwd}"
+        root_path = (rails? ? Rails.root.to_s : Dir.pwd).to_s
         FileUtils.mkdir_p(root_path + '/log')
         bullet_log_file = File.open("#{root_path}/log/bullet.log", 'a+')
         bullet_log_file.sync = true
@@ -154,6 +163,7 @@ module Bullet
 
     def notification?
       return unless start?
+
       Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
       notification_collector.notifications_present?
     end
@@ -163,7 +173,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 = {})
@@ -183,11 +193,10 @@ module Bullet
     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
 
@@ -211,23 +220,24 @@ module Bullet
     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".strip
+
+  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
+        if yes?('Would you like to enable bullet in test environment? (y/n)')
+          environment(nil, env: 'test') do
+            <<-"FILE".strip
+
+  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
+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,13 @@ 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::Schema.define(:version => 1) do
+ActiveRecord::Schema.define(version: 1) do
   create_table :posts do |t|
     t.column :title, :string
     t.column :body, :string
@@ -53,29 +55,28 @@ 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}")
+  users << User.new(name: "user#{i}")
 end
 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])
+  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 +84,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 +97,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
+      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