bullet 2.2.1 → 2.3.0

data/lib/bullet/detector/counter.rb

@@ -1,42 +1,47 @@
 module Bullet
   module Detector
     class Counter < Base
-      def self.clear
-        @@possible_objects = nil
-        @@impossible_objects = nil
-      end
+      class <<self
+        def 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
+        def add_counter_cache(object, associations)
+          if conditions_met?(object.ar_key, associations)
+            create_notification object.class.to_s, associations
+          end
         end
-      end
 
-      def self.add_possible_objects(objects)
-        possible_objects.add objects
-      end
+        def add_possible_objects(object_or_objects)
+          if object_or_objects.is_a? Array
+            object_or_objects.each { |object| possible_objects.add object.ar_key }
+          else
+            possible_objects.add object_or_objects.ar_key
+          end
+        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 add_impossible_object(object)
+          impossible_objects.add object.ar_key
+        end
 
-      def self.possible_objects
-        @@possible_objects ||= Bullet::Registry::Object.new
-      end
+        private
+          def create_notification(klazz, associations)
+             notice = Bullet::Notification::CounterCache.new klazz, associations
+             Bullet.notification_collector.add notice
+          end
 
-      def self.impossible_objects
-        @@impossible_objects ||= Bullet::Registry::Object.new
-      end
+          def possible_objects
+            @@possible_objects ||= Bullet::Registry::Object.new
+          end
+
+          def impossible_objects
+            @@impossible_objects ||= Bullet::Registry::Object.new
+          end
 
-      def self.conditions_met?( object, associations )
-        possible_objects.contains?( object ) and
-        !impossible_objects.contains?( object )
+          def conditions_met?(object_ar_key, associations)
+            possible_objects.include?(object_ar_key) && !impossible_objects.include?(object_ar_key)
+          end
       end
     end
   end

data/lib/bullet/detector/n_plus_one_query.rb

@@ -1,38 +1,57 @@
 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
+      class <<self
+        # 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 call_association(object, associations)
+          @@checked = true
+          add_call_object_associations(object, associations)
+
+          if conditions_met?(object.ar_key, associations)
+            create_notification caller_in_project, object.class.to_s, associations
+          end
         end
-      end
 
-      private
-      def self.create_notification(klazz, associations)
-        notice = Bullet::Notification::NPlusOneQuery.new( callers, klazz, associations )
-        Bullet.notification_collector.add( notice )
-      end
+        private
+          def create_notification(callers, 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
+          # decide whether the object.associations is unpreloaded or not.
+          def conditions_met?(object_ar_key, associations)
+            possible?(object_ar_key) && !impossible?(object_ar_key) && !association?(object_ar_key, associations)
+          end
+
+          def caller_in_project
+            rails_root = Rails.root.to_s
+            vendor_root = rails_root + "/vendor"
+            caller.select { |c| c.include?(rails_root) && !c.include?(vendor_root) }
+          end
+
+          def possible?(object_ar_key)
+            possible_objects.include? object_ar_key
+          end
+
+          def impossible?(object_ar_key)
+            impossible_objects.include? object_ar_key
+          end
+
+          # check if object => associations already exists in object_associations.
+          def association?(object_ar_key, associations)
+            value = object_associations[object_ar_key]
+            if value
+              value.each do |v|
+                result = v.is_a?(Hash) ? v.has_key?(associations) : v == associations
+                return true if result
+              end
+            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!
+            return false
+          end
       end
     end
   end

data/lib/bullet/detector/unused_eager_association.rb

@@ -1,40 +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?
+      class <<self
+        # check if there are unused preload associations.
+        #   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 check_unused_preload_associations
+          @@checked = true
+          object_associations.each do |object_ar_key, association|
+            object_association_diff = diff_object_association object_ar_key, association
+            next if object_association_diff.empty?
 
-          create_notification object.class, object_association_diff
+            create_notification object_ar_key.split(":").first, object_association_diff
+          end
         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
+        private
+          def create_notification(klazz, associations)
+            notice = Bullet::Notification::UnusedEagerLoading.new(klazz, associations)
+            Bullet.notification_collector.add(notice)
+          end
+
+          def call_associations(object_ar_key, association)
+            all = Set.new
+            eager_loadings.similarly_associated(object_ar_key, association).each do |related_object_ar_key|
+              coa = call_object_associations[related_object_ar_key]
+              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 ) }
+          def diff_object_association(object_ar_key, association)
+            potential_objects = association - call_associations(object_ar_key, association)
+            potential_objects.reject { |a| a.is_a?(Hash) }
+          end
       end
     end
   end

data/lib/bullet/notification/base.rb

@@ -4,18 +4,20 @@ module Bullet
       attr_accessor :notifier, :url
       attr_reader :base_class, :associations, :path
 
-      def initialize( base_class, associations, path = nil )
+      def initialize(base_class, association_or_associations, path = nil)
         @base_class = base_class
-        @associations = associations.is_a?( Array ) ? associations : [ associations ]
+        @associations = association_or_associations.is_a?(Array) ?  association_or_associations : [association_or_associations]
         @path = path
       end
 
       def title
+        raise NoMethodError.new("no method title defined")
       end
 
       def body
+        raise NoMethodError.new("no method body defined")
       end
-      
+
       def whoami
         "user: " << `whoami`.chomp
       end
@@ -33,14 +35,14 @@ module Bullet
       end
 
       def notify_inline
-        self.notifier.inline_notify( self.full_notice )
+        self.notifier.inline_notify(self.full_notice)
       end
 
       def notify_out_of_channel
-        self.notifier.out_of_channel_notify( self.full_notice )
+        self.notifier.out_of_channel_notify(self.full_notice)
       end
 
-      def eql?( other )
+      def eql?(other)
         klazz_associations_str == other.klazz_associations_str
       end
 
@@ -49,13 +51,13 @@ module Bullet
       end
 
       protected
-      def klazz_associations_str
-        "  #{@base_class} => [#{@associations.map(&:inspect).join(', ')}]"
-      end
+        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
+        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/n_plus_one_query.rb

@@ -1,8 +1,8 @@
 module Bullet
   module Notification
     class NPlusOneQuery < Base
-      def initialize( callers, base_class, associations, path = nil )
-        super( base_class, associations, path )
+      def initialize(callers, base_class, associations, path = nil)
+        super(base_class, associations, path)
 
         @callers = callers
       end
@@ -10,7 +10,7 @@ module Bullet
       def body_with_caller
         "#{body}\n#{call_stack_messages}"
       end
-      
+
       def body
         "#{klazz_associations_str}\n  Add to your finder: #{associations_str}"
       end
@@ -20,13 +20,9 @@ module Bullet
       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
-
+        def call_stack_messages
+          @callers.unshift('N+1 Query method call stack').join( "\n  " )
+        end
     end
   end
 end

data/lib/bullet/notification/unused_eager_loading.rb

@@ -6,9 +6,8 @@ module Bullet
       end
 
       def title
-        "Unused Eager Loading #{@path ? "in #{@path}" : 'detected'}" 
+        "Unused Eager Loading #{@path ? "in #{@path}" : 'detected'}"
       end
-
     end
   end
 end

data/lib/bullet/notification_collector.rb

@@ -12,14 +12,13 @@ module Bullet
       @collection = Set.new
     end
 
-    def add( value )
+    def add(value)
       @collection << value
     end
 
     def notifications_present?
       !@collection.empty?
     end
-
   end
 end
 

data/lib/bullet/rack.rb

@@ -13,7 +13,7 @@ module Bullet
 
       response_body = nil
       if Bullet.notification?
-        if status == 200 and !response.body.frozen? and check_html?(headers, response)
+        if status == 200 && !response.body.frozen? && html_request?(headers, response)
           response_body = response.body << Bullet.gather_inline_notifications
           headers['Content-Length'] = response_body.length.to_s
         end
@@ -31,8 +31,11 @@ module Bullet
       !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
+    def html_request?(headers, response)
+      headers['Content-Type'] &&
+        headers['Content-Type'].include?('text/html') &&
+        response.body.include?("<html>") &&
+        response.body.include?("</html>")
     end
 
     def no_browser_cache(headers)

data/lib/bullet/registry/association.rb

@@ -1,14 +1,12 @@
 module Bullet
   module Registry
     class Association < Base
-      def merge( base, associations )
-        @registry.merge!( { base => associations } )
+      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
+      def similarly_associated(base, associations)
+        @registry.select { |key, value| key.include?(base) && value == associations }.collect(&:first).flatten
       end
     end
   end

data/lib/bullet/registry/base.rb

@@ -11,19 +11,19 @@ module Bullet
         @registry[key]
       end
 
-      def each( &block )
-        @registry.each( &block )
+      def each(&block)
+        @registry.each(&block)
       end
 
-      def delete( base )
-        @registry.delete( base )
+      def delete(base)
+        @registry.delete(base)
       end
 
-      def select( *args, &block )
-        @registry.select( *args, &block )
+      def select(*args, &block)
+        @registry.select(*args, &block)
       end
 
-      def add( key, value )
+      def add(key, value)
         @registry[key] ||= Set.new
         if value.is_a? Array
           @registry[key] += value
@@ -32,6 +32,9 @@ module Bullet
         end
       end
 
+      def include?(key, value)
+        @registry[key] && @registry[key].include?(value)
+      end
     end
   end
 end

data/lib/bullet/registry/object.rb

@@ -1,14 +1,14 @@
 module Bullet
   module Registry
     class Object < Base
-      def add( object_or_objects )
-        klazz = object_or_objects.is_a?( Array ) ? object_or_objects.first.class :
-                                                   object_or_objects.class
-        super( klazz, object_or_objects )
+      def add(object_ar_key)
+        klazz = object_ar_key.split(":").first
+        super(klazz, object_ar_key)
       end
 
-      def contains?( object )
-        @registry[object.class] and @registry[object.class].include?( object )
+      def include?(object_ar_key)
+        klazz = object_ar_key.split(":").first
+        super(klazz, object_ar_key)
       end
     end
   end