bullet 2.0.0.beta.2 → 2.1.0

data/lib/bullet/active_record31.rb

@@ -0,0 +1,96 @@
+module Bullet
+  LOAD_TARGET_RGX = /load_target/
+  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::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_options = {})
+          origin_initialize(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)
+        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::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::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
+      end
+      
+      ::ActiveRecord::Associations::Association.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.find {|c| c =~ LOAD_TARGET_RGX }
+          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
+    end
+  end
+end

data/lib/bullet/detector/association.rb

@@ -0,0 +1,144 @@
+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)
+
+          to_add = nil
+          to_merge, to_delete = [], []
+          eager_loadings.each do |k, v|
+            key_objects_overlap = k & objects
+
+            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 - objects
+              to_merge << [keys_without_objects, eager_loadings[k]]
+              to_delete << k
+              objects = objects - k
+            end
+          end
+          if to_add
+            eager_loadings.add *to_add
+          end
+          to_merge.each do |k,val|
+            eager_loadings.merge k, val
+          end
+          to_delete.each do |k|
+            eager_loadings.delete k
+          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)
+            value = object_associations[object]
+            if value
+              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,12 @@
+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.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

data/lib/bullet/detector/unused_eager_association.rb

@@ -0,0 +1,41 @@
+module Bullet
+  module Detector
+    class UnusedEagerAssociation < Association
+      # check if there are unused preload associations.
+      # for each object => association
+      #   get related_objects from eager_loadings associated with object and associations
+      #   get call_object_association from associations of call_object_associations whose object is in related_objects 
+      #   if association not in call_object_association, then the object => association - call_object_association is ununsed preload assocations
+      def self.check_unused_preload_associations
+        @@checked = true
+        object_associations.each do |object, association|
+          object_association_diff = diff_object_association object, association
+          next if object_association_diff.empty?
+
+          create_notification object.class, object_association_diff
+        end
+      end
+      
+      protected
+      def self.create_notification(klazz, associations)
+        notice = Bullet::Notification::UnusedEagerLoading.new( klazz, associations )
+        Bullet.notification_collector.add( notice )
+      end
+
+      def self.call_object_association( object, association )
+        all = Set.new
+        eager_loadings.similarly_associated( object, association ).each do |related_object|
+            coa = call_object_associations[related_object]
+            next if coa.nil?
+            all.merge coa
+        end
+        all.to_a
+      end
+
+      def self.diff_object_association( object, association )
+        potential_objects = association - call_object_association( object, association )
+        potential_objects.reject {|a| a.is_a?( Hash ) }
+      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/notification/base.rb

@@ -0,0 +1,61 @@
+module Bullet
+  module Notification
+    class Base
+      attr_accessor :notifier, :url
+      attr_reader :base_class, :associations, :path
+
+      def initialize( base_class, associations, path = nil )
+        @base_class = base_class
+        @associations = associations.is_a?( Array ) ? associations : [ associations ]
+        @path = path
+      end
+
+      def title
+      end
+
+      def body
+      end
+      
+      def whoami
+        "user: " << `whoami`.chomp
+      end
+
+      def body_with_caller
+        body
+      end
+
+      def standard_notice
+        @standard_notifice ||= title + "\n" + body
+      end
+
+      def full_notice
+        [whoami, url, title, body_with_caller].compact.join("\n")
+      end
+
+      def notify_inline
+        self.notifier.inline_notify( self.full_notice )
+      end
+
+      def notify_out_of_channel
+        self.notifier.out_of_channel_notify( self.full_notice )
+      end
+
+      def eql?( other )
+        klazz_associations_str == other.klazz_associations_str
+      end
+
+      def hash
+        klazz_associations_str.hash
+      end
+
+      protected
+      def klazz_associations_str
+        "  #{@base_class} => [#{@associations.map(&:inspect).join(', ')}]"
+      end
+
+      def associations_str
+        ":include => #{@associations.map{|a| a.to_s.to_sym unless a.is_a? Hash}.inspect}"
+      end
+    end
+  end
+end

data/lib/bullet/notification/counter_cache.rb

@@ -0,0 +1,13 @@
+module Bullet
+  module Notification
+    class CounterCache < Base
+      def body
+        klazz_associations_str
+      end
+
+      def title
+        "Need Counter Cache"
+      end
+    end
+  end
+end

data/lib/bullet/notification/n_plus_one_query.rb

@@ -0,0 +1,32 @@
+module Bullet
+  module Notification
+    class NPlusOneQuery < Base
+      def initialize( callers, base_class, associations, path = nil )
+        super( base_class, associations, path )
+
+        @callers = callers
+      end
+
+      def body_with_caller
+        "#{body}\n#{call_stack_messages}"
+      end
+      
+      def body
+        "#{klazz_associations_str}\n  Add to your finder: #{associations_str}"
+      end
+
+      def title
+        "N+1 Query #{@path ? "in #{@path}" : 'detected'}"
+      end
+
+      protected
+      def call_stack_messages
+        @callers.collect do |c|
+          [ 'N+1 Query method call stack', 
+            c.collect {|line| "  #{line}"} ].flatten
+        end.join( "\n" )
+      end
+
+    end
+  end
+end

data/lib/bullet/notification/unused_eager_loading.rb

@@ -0,0 +1,14 @@
+module Bullet
+  module Notification
+    class UnusedEagerLoading < Base
+      def body
+        "#{klazz_associations_str}\n  Remove from your finder: #{associations_str}"
+      end
+
+      def title
+        "Unused Eager Loading #{@path ? "in #{@path}" : 'detected'}" 
+      end
+
+    end
+  end
+end

data/lib/bullet/notification.rb

@@ -1,83 +1,8 @@
 module Bullet
-  class NotificationError < StandardError
-  end
-
   module Notification
-    def notification?
-    end
-
-    def notification_response
-    end
-
-    def console_title
-    end
-
-    def log_message(path = nil)
-    end
-
-    def javascript_notification
-      str = ''
-      if Bullet.alert || Bullet.console
-        response = notification_response
-      end
-      unless response.blank?
-        if Bullet.alert
-          str << wrap_js_association("alert(#{response.join("\n").inspect});")
-        end
-        if Bullet.console
-          code = <<-CODE
-            if (typeof(console) !== 'undefined') {
-
-              if (console.groupCollapsed && console.groupEnd && console.log) {
-
-                console.groupCollapsed(#{console_title.join(', ').inspect});
-                console.log(#{response.join("\n").inspect});
-                console.log(#{call_stack_messages.join("\n").inspect});
-                console.groupEnd();
-
-              } else if (console.log) {
-
-                console.log(#{response.join("\n").inspect});
-              }
-            }
-          CODE
-          str << wrap_js_association(code)
-        end
-      end
-      str
-    end
-
-    def growl_notification
-      if Bullet.growl
-        response = notification_response
-        unless response.blank?
-          begin
-            growl = Growl.new('localhost', 'ruby-growl', ['Bullet Notification'], nil, Bullet.growl_password)
-            growl.notify('Bullet Notification', 'Bullet Notification', response.join("\n"))
-          rescue
-          end
-        end
-      end
-    end
-
-    def log_notification(path)
-      if Bullet.bullet_logger || Bullet.rails_logger
-        Rails.logger.warn '' if Bullet.rails_logger
-        messages = log_messages(path)
-        messages.each do |message|
-          Bullet.logger.info(message.join("\n")) if Bullet.bullet_logger
-          Rails.logger.warn(message.join("\n")) if Bullet.rails_logger
-        end
-        Bullet.logger_file.flush if Bullet.bullet_logger
-      end
-    end
-
-    private
-      def wrap_js_association(message)
-        str = ''
-        str << "<script type=\"text/javascript\">/*<![CDATA[*/"
-        str << message
-        str << "/*]]>*/</script>\n"
-      end
+    autoload :Base, 'bullet/notification/base'
+    autoload :UnusedEagerLoading, 'bullet/notification/unused_eager_loading'
+    autoload :NPlusOneQuery, 'bullet/notification/n_plus_one_query'
+    autoload :CounterCache, 'bullet/notification/counter_cache'
   end
 end

data/lib/bullet/notification_collector.rb

@@ -0,0 +1,25 @@
+require 'set'
+
+module Bullet
+  class NotificationCollector
+    attr_reader :collection
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @collection = Set.new
+    end
+
+    def add( value )
+      @collection << value
+    end
+
+    def notifications_present?
+      !@collection.empty?
+    end
+
+  end
+end
+

data/lib/bullet/rack.rb

@@ -0,0 +1,44 @@
+module Bullet
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless Bullet.enable?
+
+      Bullet.start_request
+      status, headers, response = @app.call(env)
+      return [status, headers, response] if empty?(response)
+
+      if Bullet.notification?
+        if status == 200 and !response.body.frozen? and check_html?(headers, response)
+          response_body = response.body << Bullet.gather_inline_notifications
+          headers['Content-Length'] = response_body.length.to_s
+        end
+        Bullet.perform_out_of_channel_notifications(env)
+      end
+      response_body ||= response.body
+      Bullet.end_request
+      no_browser_cache(headers) if Bullet.disable_browser_cache
+      [status, headers, [response_body]]
+    end
+
+    # fix issue if response's body is a Proc
+    def empty?(response)
+      # response may be ["Not Found"], ["Move Permanently"], etc.
+      (response.is_a?(Array) && response.size <= 1) ||
+      !response.body.is_a?(String) || response.body.empty?
+    end
+
+    def check_html?(headers, response)
+      headers['Content-Type'] and headers['Content-Type'].include? 'text/html' and response.body =~ %r{<html.*</html>}m
+    end
+
+    def no_browser_cache(headers)
+      headers["Cache-Control"] = "no-cache, no-store, max-age=0, must-revalidate"
+      headers["Pragma"] = "no-cache"
+      headers["Expires"] = "Wed, 09 Sep 2009 09:09:09 GMT"
+    end
+  end
+end

data/lib/bullet/registry/association.rb

@@ -0,0 +1,15 @@
+module Bullet
+  module Registry
+    class Association < Base
+      def merge( base, associations )
+        @registry.merge!( { base => associations } )
+      end
+
+      def similarly_associated( base, associations )
+        @registry.select do |key, value|
+          key.include?( base ) and value == associations
+        end.collect( &:first ).flatten
+      end
+    end
+  end
+end