thaold-bullet 2.0.2

data/lib/bullet.rb

@@ -0,0 +1,105 @@
+require 'set'
+require 'uniform_notifier'
+
+module Bullet
+  if Rails.version =~ /^3.0/
+    autoload :ActiveRecord, 'bullet/active_record3'
+  else
+    autoload :ActiveRecord, 'bullet/active_record2'
+    autoload :ActionController, 'bullet/action_controller2'
+  end
+  autoload :Rack, 'bullet/rack'
+  autoload :BulletLogger, 'bullet/logger'
+  autoload :Notification, 'bullet/notification'
+  autoload :Detector, 'bullet/detector'
+  autoload :Registry, 'bullet/registry'
+  autoload :NotificationCollector, 'bullet/notification_collector'
+
+  if defined? Rails::Railtie
+    class BulletRailtie < Rails::Railtie
+      initializer "bullet.configure_rails_initialization" do |app|
+        app.middleware.use Bullet::Rack
+      end
+    end
+  end
+
+  class <<self
+    attr_accessor :enable, :disable_browser_cache
+    attr_reader :notification_collector
+
+    delegate :alert=, :console=, :growl=, :rails_logger=, :xmpp=, :to => UniformNotifier
+
+    DETECTORS = [ Bullet::Detector::NPlusOneQuery,
+                  Bullet::Detector::UnusedEagerAssociation,
+                  Bullet::Detector::Counter ]
+
+    def enable=(enable)
+      @enable = enable
+      if enable?
+        Bullet::ActiveRecord.enable
+        if Rails.version =~ /^2./
+          Bullet::ActionController.enable
+        end
+      end
+    end
+
+    def enable?
+      @enable == true
+    end
+
+    def bullet_logger=(active)
+      if active
+        bullet_log_file = File.open( 'log/bullet.log', 'a+' )
+        bullet_log_file.sync
+        UniformNotifier.customized_logger = bullet_log_file
+      end
+    end
+
+    def start_request
+      notification_collector.reset
+      DETECTORS.each {|bullet| bullet.start_request}
+    end
+
+    def end_request
+      DETECTORS.each {|bullet| bullet.end_request}
+    end
+
+    def clear
+      DETECTORS.each {|bullet| bullet.clear}
+    end
+
+    def notification_collector
+      @notification_collector ||= Bullet::NotificationCollector.new
+    end
+
+    def notification?
+      Bullet::Detector::UnusedEagerAssociation.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" )
+    end
+
+    def perform_out_of_channel_notifications
+      for_each_active_notifier_with_notification do |notification|
+        notification.notify_out_of_channel
+      end
+    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
+        end
+      end
+  end
+
+end

data/lib/bullet/action_controller2.rb

@@ -0,0 +1,49 @@
+module Bullet
+  class ActionController
+    def self.enable
+      require 'action_controller'
+      case Rails.version
+      when /^2.3/  
+        ::ActionController::Dispatcher.middleware.use Bullet::Rack
+        ::ActionController::Dispatcher.class_eval do
+          class <<self
+            alias_method :origin_reload_application, :reload_application
+            def reload_application
+              origin_reload_application
+              Bullet.clear
+            end
+          end
+        end
+      when /^2.[2|1]/
+        ::ActionController::Dispatcher.class_eval do
+          alias_method :origin_reload_application, :reload_application
+          def reload_application
+            origin_reload_application
+            Bullet.clear
+          end
+        end
+        
+        ::ActionController::Base.class_eval do
+          alias_method :origin_process, :process
+          def process(request, response, method = :perform_action, *arguments)
+            Bullet.start_request
+            response = origin_process(request, response, method = :perform_action, *arguments)
+            
+            if Bullet.notification?
+              if response.headers["type"] and response.headers["type"].include? 'text/html' and response.body =~ %r{<html.*</html>}m
+                response.body <<= Bullet.gather_inline_notifications
+                response.headers["Content-Length"] = response.body.length.to_s
+              end
+            
+              Bullet.perform_bullet_out_of_channel_notifications
+            end
+            Bullet.end_request
+            response
+          end
+        end
+      else
+        puts "Gem Bullet: Unsupported rails version"
+      end
+    end
+  end
+end

data/lib/bullet/active_record2.rb

@@ -0,0 +1,109 @@
+module Bullet
+  module ActiveRecord
+    def self.enable
+      require 'active_record'
+      ::ActiveRecord::Base.class_eval do
+        class << self
+          alias_method :origin_find_every, :find_every
+          # 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 find_every(options)
+            records = origin_find_every(options)
+
+            if records 
+              if records.size > 1
+                Bullet::Detector::Association.add_possible_objects(records)
+                Bullet::Detector::Counter.add_possible_objects(records)
+              elsif records.size == 1
+                Bullet::Detector::Association.add_impossible_object(records.first)
+                Bullet::Detector::Counter.add_impossible_object(records.first)
+              end
+            end
+
+            records
+          end
+        end
+      end
+
+      ::ActiveRecord::AssociationPreload::ClassMethods.class_eval do
+        alias_method :origin_preload_associations, :preload_associations
+        # include query for one to many associations.
+        # keep this eager loadings.
+        def preload_associations(records, associations, preload_options={})
+          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)
+          origin_preload_associations(records, associations, preload_options={})
+        end
+      end
+
+      ::ActiveRecord::Associations::ClassMethods.class_eval do      
+        # add include in named_scope
+        alias_method :origin_find_with_associations, :find_with_associations
+        def find_with_associations(options)
+          records = origin_find_with_associations(options)
+          associations = merge_includes(scope(:find, :include), options[:include])
+          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)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::ClassMethods::JoinDependency.class_eval do
+        # call join associations
+        alias_method :origin_construct_association, :construct_association
+        def 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)
+        end
+      end
+
+      ::ActiveRecord::Associations::AssociationCollection.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
+      end
+      
+      ::ActiveRecord::Associations::AssociationProxy.class_eval do
+        # call has_one and belong_to association
+        alias_method :origin_load_target, :load_target
+        def load_target
+          # avoid stack level too deep
+          result = origin_load_target
+          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
+      
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+        def has_cached_counter?
+          result = origin_has_cached_counter?
+          Bullet::Detector::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::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bullet/active_record3.rb

@@ -0,0 +1,104 @@
+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::Association.add_possible_objects(records)
+            Bullet::Detector::Counter.add_possible_objects(records)
+          elsif records.size == 1
+            Bullet::Detector::Association.add_impossible_object(records.first)
+            Bullet::Detector::Counter.add_impossible_object(records.first)
+          end
+          records
+        end
+      end
+
+      ::ActiveRecord::AssociationPreload::ClassMethods.class_eval do
+        alias_method :origin_preload_associations, :preload_associations
+        # include query for one to many associations.
+        # keep this eager loadings.
+        def preload_associations(records, associations, preload_options={})
+          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)
+          origin_preload_associations(records, associations, preload_options={})
+        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)
+            Bullet::Detector::NPlusOneQuery.call_association(record, associations)
+          end
+          Bullet::Detector::Association.add_eager_loadings(records, associations)
+          records
+        end
+      end
+
+      ::ActiveRecord::Associations::ClassMethods::JoinDependency.class_eval do
+        alias_method :origin_construct_association, :construct_association
+        # call join associations
+        def 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)
+        end
+      end
+
+    ::ActiveRecord::Associations::AssociationCollection.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
+      end
+      
+      ::ActiveRecord::Associations::AssociationProxy.class_eval do
+        # call has_one and belong_to association
+        alias_method :origin_load_target, :load_target
+        def load_target
+          # avoid stack level too deep
+          result = origin_load_target
+          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
+
+      ::ActiveRecord::Associations::HasManyAssociation.class_eval do
+        alias_method :origin_has_cached_counter?, :has_cached_counter?
+
+        def has_cached_counter?
+          result = origin_has_cached_counter?
+          Bullet::Detector::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::Detector::Counter.add_counter_cache(@owner, @reflection.name) unless result
+          result
+        end
+      end
+    end
+  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