bullet 4.0.0 → 4.13.1

data/lib/bullet/active_record3x.rb

@@ -0,0 +1,134 @@
+module Bullet
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Relation.class_eval do
+        alias_method :origin_to_a, :to_a
+        # 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 to_a
+          records = origin_to_a
+          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
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::Preloader.class_eval do
+        # include query for one to many associations.
+        # keep this eager loadings.
+        alias_method :origin_initialize, :initialize
+        def initialize(records, associations, preload_scope = nil)
+          origin_initialize(records, associations, preload_scope)
+          records = [records].flatten.compact.uniq
+          return if records.empty?
+          records.each do |record|
+            Bullet::Detector::Association.add_object_associations(record, associations)
+          end
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
+        end
+      end
+
+      ::ActiveRecord::FinderMethods.class_eval do
+        # add includes in scope
+        alias_method :origin_find_with_associations, :find_with_associations
+        def find_with_associations
+          records = origin_find_with_associations
+          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)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_instantiate, :instantiate
+        alias_method :origin_construct_association, :construct_association
+
+        def instantiate(rows)
+          @bullet_eager_loadings = {}
+          records = origin_instantiate(rows)
+
+          @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
+          records
+        end
+
+        # call join associations
+        def construct_association(record, join, row)
+          result = origin_construct_association(record, join, row)
+
+          associations = join.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
+
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::CollectionAssociation.class_eval do
+        # call one to many associations
+        alias_method :origin_load_target, :load_target
+        def load_target
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_load_target
+        end
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_empty?
+        end
+
+        alias_method :origin_include?, :include?
+        def include?(object)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          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)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::Association.class_eval do
+        alias_method :origin_set_inverse_instance, :set_inverse_instance
+        def set_inverse_instance(record)
+          if record && invertible_for?(record)
+            Bullet::Detector::NPlusOneQuery.add_inversed_object(record, inverse_reflection_for(record).name)
+          end
+          origin_set_inverse_instance(record)
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?(reflection = reflection())
+          result = origin_has_cached_counter?(reflection)
+          Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/{active_record31.rb → active_record4.rb}

@@ -9,11 +9,11 @@ module Bullet
         def to_a
           records = origin_to_a
           if records.size > 1
-            Bullet::Detector::Association.add_possible_objects(records)
-            Bullet::Detector::Counter.add_possible_objects(records)
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(records)
+            Bullet::Detector::CounterCache.add_possible_objects(records)
           elsif records.size == 1
-            Bullet::Detector::Association.add_impossible_object(records.first)
-            Bullet::Detector::Counter.add_impossible_object(records.first)
+            Bullet::Detector::NPlusOneQuery.add_impossible_object(records.first)
+            Bullet::Detector::CounterCache.add_impossible_object(records.first)
           end
           records
         end
@@ -23,14 +23,14 @@ module Bullet
         # include query for one to many associations.
         # keep this eager loadings.
         alias_method :origin_initialize, :initialize
-        def initialize(records, associations, preload_options = {})
-          origin_initialize(records, associations, preload_options)
+        def initialize(records, associations, preload_scope = nil)
+          origin_initialize(records, associations, preload_scope)
           records = [records].flatten.compact.uniq
           return if records.empty?
           records.each do |record|
             Bullet::Detector::Association.add_object_associations(record, associations)
           end
-          Bullet::Detector::Association.add_eager_loadings(records, associations)
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
         end
       end
 
@@ -39,24 +39,42 @@ module Bullet
         alias_method :origin_find_with_associations, :find_with_associations
         def find_with_associations
           records = origin_find_with_associations
-          associations = (@eager_load_values + @includes_values).uniq
+          associations = (eager_load_values + includes_values).uniq
           records.each do |record|
             Bullet::Detector::Association.add_object_associations(record, associations)
-            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
           end
-          Bullet::Detector::Association.add_eager_loadings(records, associations)
+          Bullet::Detector::UnusedEagerLoading.add_eager_loadings(records, associations)
           records
         end
       end
 
       ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_instantiate, :instantiate
         alias_method :origin_construct_association, :construct_association
+
+        def instantiate(rows)
+          @bullet_eager_loadings = {}
+          records = origin_instantiate(rows)
+
+          @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
+          records
+        end
+
         # call join associations
         def construct_association(record, join, row)
+          result = origin_construct_association(record, join, row)
+
           associations = join.reflection.name
           Bullet::Detector::Association.add_object_associations(record, associations)
           Bullet::Detector::NPlusOneQuery.call_association(record, associations)
-          origin_construct_association(record, join, row)
+          @bullet_eager_loadings[record.class] ||= {}
+          @bullet_eager_loadings[record.class][record] ||= Set.new
+          @bullet_eager_loadings[record.class][record] << associations
+
+          result
         end
       end
 
@@ -67,6 +85,18 @@ module Bullet
           Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
           origin_load_target
         end
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_empty?
+        end
+
+        alias_method :origin_include?, :include?
+        def include?(object)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_include?(object)
+        end
       end
 
       ::ActiveRecord::Associations::SingularAssociation.class_eval do
@@ -74,8 +104,8 @@ module Bullet
         alias_method :origin_reader, :reader
         def reader(force_reload = false)
           result = origin_reader(force_reload)
-          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
-          Bullet::Detector::Association.add_possible_objects(result)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless @inversed
+          Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
           result
         end
       end
@@ -83,9 +113,9 @@ module Bullet
       ::ActiveRecord::Associations::HasManyAssociation.class_eval do
         alias_method :origin_has_cached_counter?, :has_cached_counter?
 
-        def has_cached_counter?(reflection = reflection)
+        def has_cached_counter?(reflection = reflection())
           result = origin_has_cached_counter?(reflection)
-          Bullet::Detector::Counter.add_counter_cache(owner, reflection.name) unless result
+          Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name) unless result
           result
         end
       end

data/lib/bullet/active_record41.rb

@@ -0,0 +1,128 @@
+module Bullet
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Relation.class_eval do
+        alias_method :origin_to_a, :to_a
+        # 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 to_a
+          records = origin_to_a
+          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
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::Preloader.class_eval do
+        alias_method :origin_preloaders_on, :preloaders_on
+
+        def preloaders_on(association, records, scope)
+          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
+          origin_preloaders_on(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
+          records = origin_find_with_associations
+          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)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::JoinDependency.class_eval do
+        alias_method :origin_instantiate, :instantiate
+        alias_method :origin_construct_model, :construct_model
+
+        def instantiate(result_set, aliases)
+          @bullet_eager_loadings = {}
+          records = origin_instantiate(result_set, aliases)
+
+          @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
+          records
+        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)
+
+          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
+
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::CollectionAssociation.class_eval do
+        # call one to many associations
+        alias_method :origin_load_target, :load_target
+        def load_target
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless @inversed
+          origin_load_target
+        end
+
+        alias_method :origin_empty?, :empty?
+        def empty?
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          origin_empty?
+        end
+
+        alias_method :origin_include?, :include?
+        def include?(object)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
+          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 @owner.class.name !~ /^HABTM_/
+            Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless @inversed
+            Bullet::Detector::NPlusOneQuery.add_possible_objects(result)
+          end
+          result
+        end
+      end
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?(reflection = reflection())
+          result = origin_has_cached_counter?(reflection)
+          Bullet::Detector::CounterCache.add_counter_cache(owner, reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/dependency.rb

@@ -0,0 +1,81 @@
+module Bullet
+  module Dependency
+    def mongoid?
+      @mongoid ||= defined? ::Mongoid
+    end
+
+    def active_record?
+      @active_record ||= defined? ::ActiveRecord
+    end
+
+    def rails?
+      @rails ||= defined? ::Rails
+    end
+
+    def active_record_version
+      @active_record_version ||= begin
+                                   if active_record30?
+                                     'active_record3'
+                                   elsif active_record31? || active_record32?
+                                     'active_record3x'
+                                   elsif active_record40?
+                                     'active_record4'
+                                   elsif active_record41?
+                                     'active_record41'
+                                   end
+                                 end
+    end
+
+    def mongoid_version
+      @mongoid_version ||= begin
+                             if mongoid2x?
+                               'mongoid2x'
+                             elsif mongoid3x?
+                               'mongoid3x'
+                             elsif mongoid4x?
+                               'mongoid4x'
+                             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
+    end
+
+    def active_record40?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 0
+    end
+
+    def active_record41?
+      active_record4? && ::ActiveRecord::VERSION::MINOR == 1
+    end
+
+    def mongoid2x?
+      mongoid? && ::Mongoid::VERSION =~ /\A2\.[4-8]/
+    end
+
+    def mongoid3x?
+      mongoid? && ::Mongoid::VERSION =~ /\A3/
+    end
+
+    def mongoid4x?
+      mongoid? && ::Mongoid::VERSION =~ /\A4/
+    end
+  end
+end

data/lib/bullet/detector/association.rb

@@ -2,72 +2,22 @@ module Bullet
   module Detector
     class Association < Base
       class <<self
-        def start_request
-          @@checked = false
-        end
-
-        def clear
-          # Note that under ruby class variables are shared among the class
-          # that declares them and all classes derived from that class.
-          # The following variables are accessible by all classes that
-          # derive from Bullet::Detector::Association - changing the variable
-          # in one subclass will make the change visible to all subclasses!
-          @@object_associations = nil
-          @@possible_objects = nil
-          @@impossible_objects = nil
-          @@call_object_associations = nil
-          @@eager_loadings = nil
-        end
-
         def add_object_associations(object, associations)
-          object_associations.add(object.bullet_ar_key, associations) if object.id
-        end
-
-        def add_call_object_associations(object, associations)
-          call_object_associations.add(object.bullet_ar_key, associations) if object.id
-        end
-
-        def add_possible_objects(object_or_objects)
-          return unless object_or_objects
-          if object_or_objects.is_a? Array
-            object_or_objects.each { |object| possible_objects.add object.bullet_ar_key }
-          else
-            possible_objects.add object_or_objects.bullet_ar_key if object_or_objects.id
-          end
-        end
+          return unless Bullet.start?
+          return if !Bullet.n_plus_one_query_enable? && !Bullet.unused_eager_loading_enable?
+          return unless object.primary_key_value
 
-        def add_impossible_object(object)
-          impossible_objects.add object.bullet_ar_key if object.id
+          Bullet.debug("Detector::Association#add_object_associations", "object: #{object.bullet_key}, associations: #{associations}")
+          object_associations.add(object.bullet_key, associations)
         end
 
-        def add_eager_loadings(objects, associations)
-          bullet_ar_keys = objects.map(&:bullet_ar_key)
-
-          to_add = nil
-          to_merge, to_delete = [], []
-          eager_loadings.each do |k, v|
-            key_objects_overlap = k & bullet_ar_keys
-
-            next if key_objects_overlap.empty?
-
-            if key_objects_overlap == k
-              to_add = [k, associations]
-              break
-            else
-              to_merge << [key_objects_overlap, ( eager_loadings[k].dup  << associations )]
-
-              keys_without_objects = k - bullet_ar_keys
-              to_merge << [keys_without_objects, eager_loadings[k]]
-              to_delete << k
-              bullet_ar_keys = bullet_ar_keys - k
-            end
-          end
-
-          eager_loadings.add *to_add if to_add
-          to_merge.each { |k,val| eager_loadings.merge k, val }
-          to_delete.each { |k| eager_loadings.delete k }
+        def add_call_object_associations(object, associations)
+          return unless Bullet.start?
+          return if !Bullet.n_plus_one_query_enable? && !Bullet.unused_eager_loading_enable?
+          return unless object.primary_key_value
 
-          eager_loadings.add bullet_ar_keys, associations unless bullet_ar_keys.empty?
+          Bullet.debug("Detector::Association#add_call_object_associations", "object: #{object.bullet_key}, associations: #{associations}")
+          call_object_associations.add(object.bullet_key, associations)
         end
 
         private
@@ -77,39 +27,45 @@ module Bullet
           # the object_associations keep all associations that may be or may no be
           # unpreload associations or unused preload associations.
           def object_associations
-            @@object_associations ||= Bullet::Registry::Base.new
+            Thread.current[:bullet_object_associations]
           end
 
-          # call_object_assciations keep the object relationships
+          # call_object_associations keep the object relationships
           # that object.associations is called.
           # e.g. { "Post:1" => [:comments] }
           # they are used to detect unused preload associations.
           def call_object_associations
-            @@call_object_associations ||= Bullet::Registry::Base.new
+            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
-            @@possible_objects ||= Bullet::Registry::Object.new
+            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"] }
-          # Notice: impossible_objects are not accurate,
           # 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
-            @@impossible_objects ||= Bullet::Registry::Object.new
+            Thread.current[:bullet_impossible_objects]
+          end
+
+          # inversed_objects keeps object relationships
+          # that association is inversed.
+          # e.g. { "Comment:1" => ["post"] }
+          def inversed_objects
+            Thread.current[:bullet_inversed_objects]
           end
 
           # eager_loadings keep the object relationships
           # that the associations are preloaded by find :include.
           # e.g. { ["Post:1", "Post:2"] => [:comments, :user] }
           def eager_loadings
-            @@eager_loadings ||= Bullet::Registry::Association.new
+            Thread.current[:bullet_eager_loadings]
           end
       end
     end

data/lib/bullet/detector/base.rb

@@ -1,12 +1,6 @@
 module Bullet
   module Detector
     class Base
-      def self.start_request
-      end
-
-      def self.end_request
-        clear
-      end
     end
   end
 end

data/lib/bullet/detector/counter_cache.rb

@@ -0,0 +1,59 @@
+module Bullet
+  module Detector
+    class CounterCache < Base
+      class <<self
+        def add_counter_cache(object, associations)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          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)
+            create_notification object.class.to_s, associations
+          end
+        end
+
+        def add_possible_objects(object_or_objects)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          objects = Array(object_or_objects)
+          return if objects.map(&:primary_key_value).compact.empty?
+
+          Bullet.debug("Detector::CounterCache#add_possible_objects", "objects: #{objects.map(&:bullet_key).join(', ')}")
+          objects.each { |object| possible_objects.add object.bullet_key }
+        end
+
+        def add_impossible_object(object)
+          return unless Bullet.start?
+          return unless Bullet.counter_cache_enable?
+          return unless object.primary_key_value
+
+          Bullet.debug("Detector::CounterCache#add_impossible_object", "object: #{object.bullet_key}")
+          impossible_objects.add object.bullet_key
+        end
+
+        private
+          def create_notification(klazz, associations)
+            notify_associations = Array(associations) - Bullet.get_whitelist_associations(:counter_cache, klazz)
+
+            if notify_associations.present?
+              notice = Bullet::Notification::CounterCache.new klazz, notify_associations
+              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
+end