bullet 4.13.1 → 5.5.0

data/lib/bullet/active_record5.rb

@@ -0,0 +1,243 @@
+module Bullet
+  module SaveWithBulletSupport
+    def save(*args)
+      was_new_record = new_record?
+      super(*args).tap do |result|
+        Bullet::Detector::NPlusOneQuery.add_impossible_object(self) if result && was_new_record
+      end
+    end
+
+    def save!(*args)
+      was_new_record = new_record?
+      super(*args).tap do |result|
+        Bullet::Detector::NPlusOneQuery.add_impossible_object(self) if result && was_new_record
+      end
+    end
+  end
+
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Base.class_eval do
+        class <<self
+          alias_method :origin_find_by_sql, :find_by_sql
+          def find_by_sql(sql, binds = [], preparable: nil)
+            result = origin_find_by_sql(sql, binds, preparable: nil)
+            if Bullet.start?
+              if result.is_a? Array
+                if result.size > 1
+                  Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+                  Bullet::Detector::CounterCache.add_possible_objects(result)
+                elsif result.size == 1
+                  Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
+                  Bullet::Detector::CounterCache.add_impossible_object(result.first)
+                end
+              elsif result.is_a? ::ActiveRecord::Base
+                Bullet::Detector::NPlusOneQuery.add_impossible_object(result)
+                Bullet::Detector::CounterCache.add_impossible_object(result)
+              end
+            end
+            result
+          end
+        end
+      end
+
+      ::ActiveRecord::Base.prepend(SaveWithBulletSupport)
+
+      ::ActiveRecord::Relation.class_eval do
+        alias_method :origin_records, :records
+        # if select a collection of objects, then these objects have possible to cause N+1 query.
+        # if select only one object, then the only one object has impossible to cause N+1 query.
+        def records
+          result = origin_records
+          if Bullet.start?
+            if result.first.class.name !~ /^HABTM_/
+              if result.size > 1
+                Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+                Bullet::Detector::CounterCache.add_possible_objects(result)
+              elsif result.size == 1
+                Bullet::Detector::NPlusOneQuery.add_impossible_object(result.first)
+                Bullet::Detector::CounterCache.add_impossible_object(result.first)
+              end
+            end
+          end
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::Preloader.class_eval do
+        alias_method :origin_preloaders_for_one, :preloaders_for_one
+
+        def preloaders_for_one(association, records, scope)
+          if Bullet.start?
+            records.compact!
+            if records.first.class.name !~ /^HABTM_/
+              records.each do |record|
+                Bullet::Detector::Association.add_object_associations(record, association)
+              end
+              Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, association)
+            end
+          end
+          origin_preloaders_for_one(association, records, scope)
+        end
+      end
+
+      ::ActiveRecord::FinderMethods.class_eval do
+        # add includes in scope
+        alias_method :origin_find_with_associations, :find_with_associations
+        def find_with_associations
+          return origin_find_with_associations { |r| yield r } if block_given?
+          records = origin_find_with_associations
+          if Bullet.start?
+            associations = (eager_load_values + includes_values).uniq
+            records.each do |record|
+              Bullet::Detector::Association.add_object_associations(record, associations)
+            end
+            Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
+          end
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_instantiate, :instantiate
+        alias_method :origin_construct, :construct
+        alias_method :origin_construct_model, :construct_model
+
+        def instantiate(result_set, aliases)
+          @bullet_eager_loadings = {}
+          records = origin_instantiate(result_set, aliases)
+
+          if Bullet.start?
+            @bullet_eager_loadings.each do |klazz, eager_loadings_hash|
+              objects = eager_loadings_hash.keys
+              Bullet::Detector::UnusedEagerLoading.add_eager_loadings(objects, eager_loadings_hash[objects.first].to_a)
+            end
+          end
+          records
+        end
+
+        def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+          if Bullet.start?
+            unless ar_parent.nil?
+              parent.children.each do |node|
+                key = aliases.column_alias(node, node.primary_key)
+                id = row[key]
+                if id.nil?
+                  associations = node.reflection.name
+                  Bullet::Detector::Association.add_object_associations(ar_parent, associations)
+                  Bullet::Detector::NPlusOneQuery.call_association(ar_parent, associations)
+                  @bullet_eager_loadings[ar_parent.class] ||= {}
+                  @bullet_eager_loadings[ar_parent.class][ar_parent] ||= Set.new
+                  @bullet_eager_loadings[ar_parent.class][ar_parent] << associations
+                end
+              end
+            end
+          end
+
+          origin_construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        end
+
+        # call join associations
+        def construct_model(record, node, row, model_cache, id, aliases)
+          result = origin_construct_model(record, node, row, model_cache, id, aliases)
+
+          if Bullet.start?
+            associations = node.reflection.name
+            Bullet::Detector::Association.add_object_associations(record, associations)
+            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+            @bullet_eager_loadings[record.class] ||= {}
+            @bullet_eager_loadings[record.class][record] ||= Set.new
+            @bullet_eager_loadings[record.class][record] << associations
+          end
+
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::CollectionAssociation.class_eval do
+        # call one to many associations
+        alias_method :origin_load_target, :load_target
+        def load_target
+          records = origin_load_target
+
+          if Bullet.start?
+            if self.is_a? ::ActiveRecord::Associations::ThroughAssociation
+              Bullet::Detector::NPlusOneQuery.call_association(owner, through_reflection.name)
+              association = self.owner.association self.through_reflection.name
+              Array(association.target).each do |through_record|
+                Bullet::Detector::NPlusOneQuery.call_association(through_record, source_reflection.name)
+              end
+            end
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name) unless @inversed
+            if records.first.class.name !~ /^HABTM_/
+              if records.size > 1
+                Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+                Bullet::Detector::CounterCache.add_possible_objects(records)
+              elsif records.size == 1
+                Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+                Bullet::Detector::CounterCache.add_impossible_object(records.first)
+              end
+            end
+          end
+          records
+        end
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          if Bullet.start? && !reflection.has_cached_counter?
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+          end
+          origin_empty?
+        end
+
+        alias_method :origin_include?, :include?
+        def include?(object)
+          if Bullet.start?
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+          end
+          origin_include?(object)
+        end
+      end
+
+      ::ActiveRecord::Associations::SingularAssociation.class_eval do
+        # call has_one and belongs_to associations
+        alias_method :origin_reader, :reader
+        def reader(force_reload = false)
+          result = origin_reader(force_reload)
+          if Bullet.start?
+            if owner.class.name !~ /^HABTM_/ && !@inversed
+              Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+              if Bullet::Detector::NPlusOneQuery.impossible?(owner)
+                Bullet::Detector::NPlusOneQuery.add_impossible_object(result) if result
+              else
+                Bullet::Detector::NPlusOneQuery.add_possible_objects(result) if result
+              end
+            end
+          end
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_many_empty?, :empty?
+        def empty?
+          result = origin_many_empty?
+          if Bullet.start? && !reflection.has_cached_counter?
+            Bullet::Detector::NPlusOneQuery.call_association(owner, reflection.name)
+          end
+          result
+        end
+
+        alias_method :origin_count_records, :count_records
+        def count_records
+          result = reflection.has_cached_counter?
+          if Bullet.start? && !result && !self.is_a?(::ActiveRecord::Associations::ThroughAssociation)
+            Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name)
+          end
+          origin_count_records
+        end
+      end
+    end
+  end
+end

data/lib/bullet/dependency.rb

@@ -14,48 +14,42 @@ module Bullet
 
     def active_record_version
       @active_record_version ||= begin
-                                   if active_record30?
-                                     'active_record3'
-                                   elsif active_record31? || active_record32?
-                                     'active_record3x'
-                                   elsif active_record40?
+                                   if active_record40?
                                      'active_record4'
                                    elsif active_record41?
                                      'active_record41'
+                                   elsif active_record42?
+                                     'active_record42'
+                                   elsif active_record50?
+                                     'active_record5'
+                                   elsif active_record51?
+                                     'active_record5'
+                                   else
+                                     raise "Bullet does not support active_record #{::ActiveRecord::VERSION} yet"
                                    end
                                  end
     end
 
     def mongoid_version
       @mongoid_version ||= begin
-                             if mongoid2x?
-                               'mongoid2x'
-                             elsif mongoid3x?
-                               'mongoid3x'
-                             elsif mongoid4x?
+                             if mongoid4x?
                                'mongoid4x'
+                             elsif mongoid5x?
+                               'mongoid5x'
+                             elsif mongoid6x?
+                               'mongoid6x'
+                             else
+                               raise "Bullet does not support mongoid #{::Mongoid::VERSION} yet"
                              end
                            end
     end
 
-    def active_record3?
-      active_record? && ::ActiveRecord::VERSION::MAJOR == 3
-    end
-
     def active_record4?
       active_record? && ::ActiveRecord::VERSION::MAJOR == 4
     end
 
-    def active_record30?
-      active_record3? && ::ActiveRecord::VERSION::MINOR == 0
-    end
-
-    def active_record31?
-      active_record3? && ::ActiveRecord::VERSION::MINOR == 1
-    end
-
-    def active_record32?
-      active_record3? && ::ActiveRecord::VERSION::MINOR == 2
+    def active_record5?
+      active_record? && ::ActiveRecord::VERSION::MAJOR == 5
     end
 
     def active_record40?
@@ -66,16 +60,28 @@ module Bullet
       active_record4? && ::ActiveRecord::VERSION::MINOR == 1
     end
 
-    def mongoid2x?
-      mongoid? && ::Mongoid::VERSION =~ /\A2\.[4-8]/
+    def active_record42?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 2
     end
 
-    def mongoid3x?
-      mongoid? && ::Mongoid::VERSION =~ /\A3/
+    def active_record50?
+      active_record5? && ::ActiveRecord::VERSION::MINOR == 0
+    end
+
+    def active_record51?
+      active_record5? && ::ActiveRecord::VERSION::MINOR == 1
     end
 
     def mongoid4x?
       mongoid? && ::Mongoid::VERSION =~ /\A4/
     end
+
+    def mongoid5x?
+      mongoid? && ::Mongoid::VERSION =~ /\A5/
+    end
+
+    def mongoid6x?
+      mongoid? && ::Mongoid::VERSION =~ /\A6/
+    end
   end
 end

data/lib/bullet/detector/association.rb

@@ -20,6 +20,22 @@ module Bullet
           call_object_associations.add(object.bullet_key, associations)
         end
 
+        # possible_objects keep the class to object relationships
+        # that the objects may cause N+1 query.
+        # e.g. { Post => ["Post:1", "Post:2"] }
+        def possible_objects
+          Thread.current[:bullet_possible_objects]
+        end
+
+        # impossible_objects keep the class to objects relationships
+        # that the objects may not cause N+1 query.
+        # e.g. { Post => ["Post:1", "Post:2"] }
+        # if find collection returns only one object, then the object is impossible object,
+        # impossible_objects are used to avoid treating 1+1 query to N+1 query.
+        def impossible_objects
+          Thread.current[:bullet_impossible_objects]
+        end
+
         private
           # object_associations keep the object relationships
           # that the object has many associations.
@@ -38,22 +54,6 @@ module Bullet
             Thread.current[:bullet_call_object_associations]
           end
 
-          # possible_objects keep the class to object relationships
-          # that the objects may cause N+1 query.
-          # e.g. { Post => ["Post:1", "Post:2"] }
-          def possible_objects
-            Thread.current[:bullet_possible_objects]
-          end
-
-          # impossible_objects keep the class to objects relationships
-          # that the objects may not cause N+1 query.
-          # e.g. { Post => ["Post:1", "Post:2"] }
-          # if find collection returns only one object, then the object is impossible object,
-          # impossible_objects are used to avoid treating 1+1 query to N+1 query.
-          def impossible_objects
-            Thread.current[:bullet_impossible_objects]
-          end
-
           # inversed_objects keeps object relationships
           # that association is inversed.
           # e.g. { "Comment:1" => ["post"] }

data/lib/bullet/detector/counter_cache.rb

@@ -8,7 +8,7 @@ module Bullet
           return unless object.primary_key_value
 
           Bullet.debug("Detector::CounterCache#add_counter_cache", "object: #{object.bullet_key}, associations: #{associations}")
-          if conditions_met?(object.bullet_key, associations)
+          if conditions_met?(object, associations)
             create_notification object.class.to_s, associations
           end
         end
@@ -32,6 +32,18 @@ module Bullet
           impossible_objects.add object.bullet_key
         end
 
+        def conditions_met?(object, associations)
+          possible_objects.include?(object.bullet_key) && !impossible_objects.include?(object.bullet_key)
+        end
+
+        def possible_objects
+          Thread.current[:bullet_counter_possible_objects]
+        end
+
+        def impossible_objects
+          Thread.current[:bullet_counter_impossible_objects]
+        end
+
         private
           def create_notification(klazz, associations)
             notify_associations = Array(associations) - Bullet.get_whitelist_associations(:counter_cache, klazz)
@@ -41,18 +53,6 @@ module Bullet
               Bullet.notification_collector.add notice
             end
           end
-
-          def possible_objects
-            Thread.current[:bullet_counter_possible_objects]
-          end
-
-          def impossible_objects
-            Thread.current[:bullet_counter_impossible_objects]
-          end
-
-          def conditions_met?(bullet_key, associations)
-            possible_objects.include?(bullet_key) && !impossible_objects.include?(bullet_key)
-          end
       end
     end
   end

data/lib/bullet/detector/n_plus_one_query.rb

@@ -2,6 +2,7 @@ module Bullet
   module Detector
     class NPlusOneQuery < Association
       extend Dependency
+      extend StackTraceFilter
 
       class <<self
         # executed when object.assocations is called.
@@ -15,7 +16,7 @@ module Bullet
           add_call_object_associations(object, associations)
 
           Bullet.debug("Detector::NPlusOneQuery#call_association", "object: #{object.bullet_key}, associations: #{associations}")
-          if conditions_met?(object.bullet_key, associations)
+          if !excluded_stacktrace_path? && conditions_met?(object, associations)
             Bullet.debug("detect n + 1 query", "object: #{object.bullet_key}, associations: #{associations}")
             create_notification caller_in_project, object.class.to_s, associations
           end
@@ -49,49 +50,43 @@ module Bullet
           inversed_objects.add object.bullet_key, association
         end
 
-        private
-          def create_notification(callers, klazz, associations)
-            notify_associations = Array(associations) - Bullet.get_whitelist_associations(:n_plus_one_query, klazz)
+        # decide whether the object.associations is unpreloaded or not.
+        def conditions_met?(object, associations)
+          possible?(object) && !impossible?(object) && !association?(object, associations)
+        end
 
-            if notify_associations.present?
-              notice = Bullet::Notification::NPlusOneQuery.new(callers, klazz, notify_associations)
-              Bullet.notification_collector.add(notice)
-            end
-          end
+        def possible?(object)
+          possible_objects.include? object.bullet_key
+        end
 
-          # decide whether the object.associations is unpreloaded or not.
-          def conditions_met?(bullet_key, associations)
-            possible?(bullet_key) && !impossible?(bullet_key) && !association?(bullet_key, associations)
-          end
+        def impossible?(object)
+          impossible_objects.include? object.bullet_key
+        end
 
-          def caller_in_project
-            app_root = rails? ? Rails.root.to_s : Dir.pwd
-            vendor_root = app_root + "/vendor"
-            caller.select do |c|
-              c.include?(app_root) && !c.include?(vendor_root) ||
-              Bullet.stacktrace_includes.any? { |include| c.include?(include) }
+        # check if object => associations already exists in object_associations.
+        def association?(object, associations)
+          value = object_associations[object.bullet_key]
+          if value
+            value.each do |v|
+              # associations == v comparision order is important here because
+              # v variable might be a squeel node where :== method is redefined,
+              # so it does not compare values at all and return unexpected results
+              result = v.is_a?(Hash) ? v.key?(associations) : associations == v
+              return true if result
             end
           end
 
-          def possible?(bullet_key)
-            possible_objects.include? bullet_key
-          end
+          false
+        end
 
-          def impossible?(bullet_key)
-            impossible_objects.include? bullet_key
-          end
+        private
+          def create_notification(callers, klazz, associations)
+            notify_associations = Array(associations) - Bullet.get_whitelist_associations(:n_plus_one_query, klazz)
 
-          # check if object => associations already exists in object_associations.
-          def association?(bullet_key, associations)
-            value = object_associations[bullet_key]
-            if value
-              value.each do |v|
-                result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations
-                return true if result
-              end
+            if notify_associations.present?
+              notice = Bullet::Notification::NPlusOneQuery.new(callers, klazz, notify_associations)
+              Bullet.notification_collector.add(notice)
             end
-
-            return false
           end
       end
     end

data/lib/bullet/detector/unused_eager_loading.rb

@@ -1,6 +1,9 @@
 module Bullet
   module Detector
     class UnusedEagerLoading < Association
+      extend Dependency
+      extend StackTraceFilter
+
       class <<self
         # check if there are unused preload associations.
         #   get related_objects from eager_loadings associated with object and associations
@@ -15,7 +18,7 @@ module Bullet
             next if object_association_diff.empty?
 
             Bullet.debug("detect unused preload", "object: #{bullet_key}, associations: #{object_association_diff}")
-            create_notification bullet_key.bullet_class_name, object_association_diff
+            create_notification(caller_in_project, bullet_key.bullet_class_name, object_association_diff)
           end
         end
 
@@ -27,39 +30,37 @@ module Bullet
           Bullet.debug("Detector::UnusedEagerLoading#add_eager_loadings", "objects: #{objects.map(&:bullet_key).join(', ')}, associations: #{associations}")
           bullet_keys = objects.map(&:bullet_key)
 
-          to_add = nil
-          to_merge, to_delete = [], []
+          to_add, to_merge, to_delete = [], [], []
           eager_loadings.each do |k, v|
             key_objects_overlap = k & bullet_keys
 
             next if key_objects_overlap.empty?
 
+            bullet_keys = bullet_keys - k
             if key_objects_overlap == k
-              to_add = [k, associations]
-              break
+              to_add << [k, associations]
             else
               to_merge << [key_objects_overlap, ( eager_loadings[k].dup  << associations )]
 
-              keys_without_objects = k - bullet_keys
+              keys_without_objects = k - key_objects_overlap
               to_merge << [keys_without_objects, eager_loadings[k]]
               to_delete << k
-              bullet_keys = bullet_keys - k
             end
           end
 
-          eager_loadings.add *to_add if to_add
-          to_merge.each { |k,val| eager_loadings.merge k, val }
+          to_add.each { |k, val| eager_loadings.add k, val }
+          to_merge.each { |k, val| eager_loadings.merge k, val }
           to_delete.each { |k| eager_loadings.delete k }
 
           eager_loadings.add bullet_keys, associations unless bullet_keys.empty?
         end
 
         private
-          def create_notification(klazz, associations)
+          def create_notification(callers, klazz, associations)
             notify_associations = Array(associations) - Bullet.get_whitelist_associations(:unused_eager_loading, klazz)
 
             if notify_associations.present?
-              notice = Bullet::Notification::UnusedEagerLoading.new(klazz, notify_associations)
+              notice = Bullet::Notification::UnusedEagerLoading.new(callers, klazz, notify_associations)
               Bullet.notification_collector.add(notice)
             end
           end

data/lib/bullet/ext/object.rb

@@ -1,10 +1,12 @@
 class Object
   def bullet_key
-    [self.class, self.primary_key_value].join(':')
+    "#{self.class}:#{self.primary_key_value}"
   end
 
   def primary_key_value
-    if self.class.respond_to?(:primary_key) && self.class.primary_key
+    if self.class.respond_to?(:primary_keys) && self.class.primary_keys
+      self.class.primary_keys.map { |primary_key| self.send primary_key }.join(',')
+    elsif self.class.respond_to?(:primary_key) && self.class.primary_key
       self.send self.class.primary_key
     else
       self.id

data/lib/bullet/{mongoid3x.rb → mongoid5x.rb}

@@ -21,7 +21,7 @@ module Bullet
         end
 
         def each(&block)
-          records = query.map{ |doc| ::Mongoid::Factory.from_db(klass, doc) }
+          records = view.map{ |doc| ::Mongoid::Factory.from_db(klass, doc) }
           if records.length > 1
             Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
           elsif records.size == 1
@@ -43,8 +43,8 @@ module Bullet
       ::Mongoid::Relations::Accessors.class_eval do
         alias_method :origin_get_relation, :get_relation
 
-        def get_relation(name, metadata, reload = false)
-          result = origin_get_relation(name, metadata, reload)
+        def get_relation(name, metadata, object, reload = false)
+          result = origin_get_relation(name, metadata, object, reload)
           if metadata.macro !~ /embed/
             Bullet::Detector::NPlusOneQuery.call_association(self, name)
           end