bullet 2.0.0.beta.2 → 2.0.0.beta.3

data/lib/bullet/action_controller2.rb

@@ -3,7 +3,8 @@ module Bullet
     def self.enable
       require 'action_controller'
       case Rails.version
-      when /^2.3/
+      when /^2.3/  
+        ::ActionController::Dispatcher.middleware.use Bullet::Rack
         ::ActionController::Dispatcher.class_eval do
           class <<self
             alias_method :origin_reload_application, :reload_application
@@ -30,12 +31,11 @@ module Bullet
             
             if Bullet.notification?
               if response.headers["type"] and response.headers["type"].include? 'text/html' and response.body =~ %r{<html.*</html>}m
-                response.body <<= Bullet.javascript_notification
+                response.body <<= Bullet.gather_inline_notifications
                 response.headers["Content-Length"] = response.body.length.to_s
               end
             
-              Bullet.growl_notification
-              Bullet.log_notification(request.params['PATH_INFO'])
+              Bullet.perform_bullet_out_of_channel_notifications
             end
             Bullet.end_request
             response

data/lib/bullet/active_record2.rb

@@ -12,11 +12,11 @@ module Bullet
 
             if records 
               if records.size > 1
-                Bullet::Association.add_possible_objects(records)
-                Bullet::Counter.add_possible_objects(records)
+                Bullet::Detector::Association.add_possible_objects(records)
+                Bullet::Detector::Counter.add_possible_objects(records)
               elsif records.size == 1
-                Bullet::Association.add_impossible_object(records.first)
-                Bullet::Counter.add_impossible_object(records.first)
+                Bullet::Detector::Association.add_impossible_object(records.first)
+                Bullet::Detector::Counter.add_impossible_object(records.first)
               end
             end
 
@@ -33,9 +33,9 @@ module Bullet
           records = [records].flatten.compact.uniq
           return if records.empty?
           records.each do |record|
-            Bullet::Association.add_object_associations(record, associations)
+            Bullet::Detector::Association.add_object_associations(record, associations)
           end
-          Bullet::Association.add_eager_loadings(records, associations)
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
           origin_preload_associations(records, associations, preload_options={})
         end
       end
@@ -47,10 +47,10 @@ module Bullet
           records = origin_find_with_associations(options)
           associations = merge_includes(scope(:find, :include), options[:include])
           records.each do |record|
-            Bullet::Association.add_object_associations(record, associations)
-            Bullet::Association.call_association(record, associations)
+            Bullet::Detector::Association.add_object_associations(record, associations)
+            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
           end
-          Bullet::Association.add_eager_loadings(records, associations)
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
           records
         end
       end
@@ -60,8 +60,8 @@ module Bullet
         alias_method :origin_construct_association, :construct_association
         def construct_association(record, join, row)
           associations = join.reflection.name
-          Bullet::Association.add_object_associations(record, associations)
-          Bullet::Association.call_association(record, associations)
+          Bullet::Detector::Association.add_object_associations(record, associations)
+          Bullet::Detector::NPlusOneQuery.call_association(record, associations)
           origin_construct_association(record, join, row)
         end
       end
@@ -70,7 +70,7 @@ module Bullet
         # call one to many associations
         alias_method :origin_load_target, :load_target
         def load_target
-          Bullet::Association.call_association(@owner, @reflection.name)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
           origin_load_target
         end
       end
@@ -81,8 +81,8 @@ module Bullet
         def load_target
           # avoid stack level too deep
           result = origin_load_target
-          Bullet::Association.call_association(@owner, @reflection.name) unless caller.to_s.include? 'load_target'
-          Bullet::Association.add_possible_objects(result)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.to_s.include? 'load_target'
+          Bullet::Detector::Association.add_possible_objects(result)
           result
         end
       end
@@ -91,7 +91,7 @@ module Bullet
         alias_method :origin_has_cached_counter?, :has_cached_counter?
         def has_cached_counter?
           result = origin_has_cached_counter?
-          Bullet::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          Bullet::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
           result
         end
       end
@@ -100,7 +100,7 @@ module Bullet
         alias_method :origin_has_cached_counter?, :has_cached_counter?
         def has_cached_counter?
           result = origin_has_cached_counter?
-          Bullet::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          Bullet::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
           result
         end
       end

data/lib/bullet/active_record3.rb

@@ -9,11 +9,11 @@ module Bullet
         def to_a
           records = origin_to_a
           if records.size > 1
-            Bullet::Association.add_possible_objects(records)
-            Bullet::Counter.add_possible_objects(records)
+            Bullet::Detector::Association.add_possible_objects(records)
+            Bullet::Detector::Counter.add_possible_objects(records)
           elsif records.size == 1
-            Bullet::Association.add_impossible_object(records.first)
-            Bullet::Counter.add_impossible_object(records.first)
+            Bullet::Detector::Association.add_impossible_object(records.first)
+            Bullet::Detector::Counter.add_impossible_object(records.first)
           end
           records
         end
@@ -27,9 +27,9 @@ module Bullet
           records = [records].flatten.compact.uniq
           return if records.empty?
           records.each do |record|
-            Bullet::Association.add_object_associations(record, associations)
+            Bullet::Detector::Association.add_object_associations(record, associations)
           end
-          Bullet::Association.add_eager_loadings(records, associations)
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
           origin_preload_associations(records, associations, preload_options={})
         end
       end
@@ -41,10 +41,10 @@ module Bullet
           records = origin_find_with_associations
           associations = (@eager_load_values + @includes_values).uniq
           records.each do |record|
-            Bullet::Association.add_object_associations(record, associations)
-            Bullet::Association.call_association(record, associations)
+            Bullet::Detector::Association.add_object_associations(record, associations)
+            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
           end
-          Bullet::Association.add_eager_loadings(records, associations)
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
           records
         end
       end
@@ -54,8 +54,8 @@ module Bullet
         # call join associations
         def construct_association(record, join, row)
           associations = join.reflection.name
-          Bullet::Association.add_object_associations(record, associations)
-          Bullet::Association.call_association(record, associations)
+          Bullet::Detector::Association.add_object_associations(record, associations)
+          Bullet::Detector::NPlusOneQuery.call_association(record, associations)
           origin_construct_association(record, join, row)
         end
       end
@@ -64,7 +64,7 @@ module Bullet
         # call one to many associations
         alias_method :origin_load_target, :load_target
         def load_target
-          Bullet::Association.call_association(@owner, @reflection.name)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name)
           origin_load_target
         end
       end
@@ -75,8 +75,8 @@ module Bullet
         def load_target
           # avoid stack level too deep
           result = origin_load_target
-          Bullet::Association.call_association(@owner, @reflection.name) unless caller.to_s.include? 'load_target'
-          Bullet::Association.add_possible_objects(result)
+          Bullet::Detector::NPlusOneQuery.call_association(@owner, @reflection.name) unless caller.to_s.include? 'load_target'
+          Bullet::Detector::Association.add_possible_objects(result)
           result
         end
       end
@@ -86,7 +86,7 @@ module Bullet
 
         def has_cached_counter?
           result = origin_has_cached_counter?
-          Bullet::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          Bullet::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
           result
         end
       end
@@ -95,16 +95,7 @@ module Bullet
         alias_method :origin_has_cached_counter?, :has_cached_counter?
         def has_cached_counter?
           result = origin_has_cached_counter?
-          Bullet::Counter.add_counter_cache(@owner, @reflection.name) unless result
-          result
-        end
-      end
-      
-      ::ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
-        alias_method :origin_has_cached_counter?, :has_cached_counter?
-        def has_cached_counter?
-          result = origin_has_cached_counter?
-          Bullet::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          Bullet::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
           result
         end
       end

data/lib/bullet/detector.rb

@@ -0,0 +1,9 @@
+module Bullet
+  module Detector
+    autoload :Base, 'bullet/detector/base'
+    autoload :Association, 'bullet/detector/association'
+    autoload :NPlusOneQuery, 'bullet/detector/n_plus_one_query'
+    autoload :UnusedEagerAssociation, 'bullet/detector/unused_eager_association'
+    autoload :Counter, 'bullet/detector/counter'
+  end
+end

data/lib/bullet/detector/association.rb

@@ -0,0 +1,135 @@
+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
+          @@callers = 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, associations )
+        end
+
+        def add_call_object_associations(object, associations)
+          call_object_associations.add( object, associations )
+        end
+
+        def add_possible_objects(objects)
+          possible_objects.add objects
+        end
+
+        def add_impossible_object(object)
+          impossible_objects.add object
+        end
+
+        def add_eager_loadings(objects, associations)
+          objects = Array(objects)
+
+          eager_loadings.each do |k, v|
+            key_objects_overlap = k & objects
+
+            next if key_objects_overlap.empty?
+
+            if key_objects_overlap == k
+              eager_loadings.add k, associations
+              break
+
+            else
+              eager_loadings.merge key_objects_overlap, ( eager_loadings[k].dup  << associations )
+
+              keys_without_objects = k - objects
+              eager_loadings.merge keys_without_objects, eager_loadings[k] unless keys_without_objects.empty?
+
+              eager_loadings.delete(k)
+              objects = objects - k
+            end
+          end
+
+          eager_loadings.add objects, associations unless objects.empty?
+        end
+
+        private
+          def possible?(object)
+            possible_objects.contains? object
+          end
+
+          def impossible?(object)
+            impossible_objects.contains? object
+          end
+
+          # check if object => associations already exists in object_associations.
+          def association?(object, associations)
+            object_associations.each do |key, value|
+              next unless key == object
+
+              value.each do |v|
+                result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations
+                return true if result
+              end
+
+            end
+            return false
+          end
+
+          # object_associations keep the object relationships 
+          # that the object has many associations.
+          # e.g. { <Post id:1> => [:comments] }
+          # 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
+          end
+
+          # call_object_assciations keep the object relationships
+          # that object.associations is called.
+          # e.g. { <Post id:1> => [:comments] }
+          # they are used to detect unused preload associations.
+          def call_object_associations
+            @@call_object_associations ||= Bullet::Registry::Base.new
+          end
+
+          # possible_objects keep the class to object relationships
+          # that the objects may cause N+1 query.
+          # e.g. { Post => [<Post id:1>, <Post id:2>] }
+          def possible_objects
+            @@possible_objects ||= Bullet::Registry::Object.new
+          end
+
+          # impossible_objects keep the class to objects relationships
+          # that the objects may not cause N+1 query.
+          # e.g. { Post => [<Post id:1>, <Post id: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
+          end
+
+          # eager_loadings keep the object relationships
+          # that the associations are preloaded by find :include.
+          # e.g. { [<Post id:1>, <Post id:2>] => [:comments, :user] }
+          def eager_loadings
+            @@eager_loadings ||= Bullet::Registry::Association.new
+          end
+
+          def callers
+            @@callers ||= []
+          end
+      end
+    end
+  end
+end

data/lib/bullet/detector/base.rb

@@ -0,0 +1,19 @@
+module Bullet
+  module Detector
+    class Base
+      def self.start_request
+      end
+
+      def self.end_request
+        clear
+      end
+
+      protected
+      def self.unique( array )
+        array.flatten!
+        array.uniq!
+      end
+
+    end
+  end
+end

data/lib/bullet/detector/counter.rb

@@ -0,0 +1,43 @@
+module Bullet
+  module Detector
+    class Counter < Base
+      def self.clear
+        @@possible_objects = nil
+        @@impossible_objects = nil
+      end
+
+      def self.add_counter_cache(object, associations)
+        if conditions_met?( object, associations )
+          create_notification object.class, associations
+        end
+      end
+
+      def self.add_possible_objects(objects)
+        possible_objects.add objects
+      end
+
+      def self.add_impossible_object(object)
+        impossible_objects.add object
+      end
+      
+      private
+      def self.create_notification( klazz, associations )
+         notice = Bullet::Notification::CounterCache.new klazz, associations
+         Bullet.notification_collector.add notice
+      end
+
+      def self.possible_objects
+        @@possible_objects ||= Bullet::Registry::Object.new
+      end
+
+      def self.impossible_objects
+        @@impossible_objects ||= Bullet::Registry::Object.new
+      end
+
+      def self.conditions_met?( object, associations )
+        possible_objects.contains?( object ) and
+        !impossible_objects.contains?( object )
+      end
+    end
+  end
+end

data/lib/bullet/detector/n_plus_one_query.rb

@@ -0,0 +1,39 @@
+module Bullet
+  module Detector
+    class NPlusOneQuery < Association
+      # executed when object.assocations is called.
+      # first, it keeps this method call for object.association.
+      # then, it checks if this associations call is unpreload.
+      #   if it is, keeps this unpreload associations and caller.
+      def self.call_association(object, associations)
+        @@checked = true
+        add_call_object_associations(object, associations)
+
+        if conditions_met?(object, associations)
+          caller_in_project
+          create_notification object.class, associations
+        end
+      end
+
+      private
+      def self.create_notification(klazz, associations)
+        notice = Bullet::Notification::NPlusOneQuery.new( callers, klazz, associations )
+        Bullet.notification_collector.add( notice )
+      end
+
+      # decide whether the object.associations is unpreloaded or not.
+      def self.conditions_met?(object, associations)
+        possible?(object) and 
+        !impossible?(object) and 
+        !association?(object, associations)
+      end
+
+      def self.caller_in_project
+        vender_root ||= File.join(Rails.root, 'vendor')
+        callers << caller.select { |c| c =~ /#{Rails.root}/ }.
+                          reject { |c| c =~ /#{vender_root}/ }
+        callers.uniq!
+      end
+    end
+  end
+end