bullet_instructure 4.0.2

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
+        markdown(("##")+("Need Counter Cache"))
+      end
+    end
+  end
+end

data/lib/bullet/notification/n_plus_one_query.rb

@@ -0,0 +1,28 @@
+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
+        markdown("#{body}\n#{call_stack_messages}")
+      end
+
+      def body
+        "#{klazz_associations_str}\n  Add to your finder: #{associations_str}"
+      end
+
+      def title
+        markdown(("##")+"N+1 Query #{@path ? "in #{@path}" : 'detected'}")
+      end
+
+      protected
+        def call_stack_messages
+          markdown((['N+1 Query method call stack'] + @callers).join( "\n  " ))
+        end
+    end
+  end
+end

data/lib/bullet/notification/unused_eager_loading.rb

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

data/lib/bullet/notification_collector.rb

@@ -0,0 +1,24 @@
+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,81 @@
+module Bullet
+  class Rack
+    include Dependency
+
+    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 file?(headers) || sse?(response) || empty?(response)
+
+      response_body = nil
+      if Bullet.notification?
+        if status == 200 && !response_body(response).frozen? && html_request?(headers, response)
+          response_body = response_body(response) << Bullet.gather_inline_notifications
+          add_footer_note(response_body) if Bullet.add_footer
+          headers['Content-Length'] = response_body.bytesize.to_s
+        end
+      end
+      [status, headers, response_body ? [response_body] : response]
+    ensure
+      if Bullet.enable? && Bullet.notification?
+        Bullet.perform_out_of_channel_notifications(env)
+      end
+      Bullet.end_request
+    end
+
+    # fix issue if response's body is a Proc
+    def empty?(response)
+      # response may be ["Not Found"], ["Move Permanently"], etc.
+      if rails?
+        (response.is_a?(Array) && response.size <= 1) ||
+          !response.respond_to?(:body) ||
+          !response_body(response).respond_to?(:empty?) ||
+          response_body(response).empty?
+      else
+        body = response_body(response)
+        body.nil? || body.empty?
+      end
+    end
+
+    def add_footer_note(response_body)
+      response_body << "<div #{footer_div_style}>" + Bullet.footer_info.uniq.join("<br>") + "</div>"
+    end
+
+    def file?(headers)
+      headers["Content-Transfer-Encoding"] == "binary"
+    end
+
+    def sse?(response)
+      response.respond_to?(:stream) && response.stream.is_a?(ActionController::Live::Buffer)
+    end
+
+    def html_request?(headers, response)
+      headers['Content-Type'] && headers['Content-Type'].include?('text/html') && response_body(response).include?("<html")
+    end
+
+    def response_body(response)
+      if rails?
+        Array === response.body ? response.body.first : response.body
+      else
+        response.first
+      end
+    end
+
+    private
+    def footer_div_style
+<<EOF
+style="position: fixed; bottom: 0pt; left: 0pt; cursor: pointer; border-style: solid; border-color: rgb(153, 153, 153);
+ -moz-border-top-colors: none; -moz-border-right-colors: none; -moz-border-bottom-colors: none;
+ -moz-border-left-colors: none; -moz-border-image: none; border-width: 2pt 2pt 0px 0px;
+ padding: 5px; border-radius: 0pt 10pt 0pt 0px; background: none repeat scroll 0% 0% rgba(200, 200, 200, 0.8);
+ color: rgb(119, 119, 119); font-size: 18px; font-family: 'Arial', sans-serif; z-index:9999;"
+EOF
+    end
+  end
+end
+

data/lib/bullet/registry.rb

@@ -0,0 +1,7 @@
+module Bullet
+  module Registry
+    autoload :Base, 'bullet/registry/base'
+    autoload :Object, 'bullet/registry/object'
+    autoload :Association, 'bullet/registry/association'
+  end
+end

data/lib/bullet/registry/association.rb

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

data/lib/bullet/registry/base.rb

@@ -0,0 +1,40 @@
+module Bullet
+  module Registry
+    class Base
+      attr_reader :registry
+
+      def initialize
+        @registry = {}
+      end
+
+      def [](key)
+        @registry[key]
+      end
+
+      def each(&block)
+        @registry.each(&block)
+      end
+
+      def delete(base)
+        @registry.delete(base)
+      end
+
+      def select(*args, &block)
+        @registry.select(*args, &block)
+      end
+
+      def add(key, value)
+        @registry[key] ||= Set.new
+        if value.is_a? Array
+          @registry[key] += value
+        else
+          @registry[key] << value
+        end
+      end
+
+      def include?(key, value)
+        !@registry[key].nil? && @registry[key].include?(value)
+      end
+    end
+  end
+end

data/lib/bullet/registry/object.rb

@@ -0,0 +1,13 @@
+module Bullet
+  module Registry
+    class Object < Base
+      def add(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
+      end
+
+      def include?(bullet_key)
+        super(bullet_key.bullet_class_name, bullet_key)
+      end
+    end
+  end
+end

data/lib/bullet/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Bullet
+  VERSION = "4.0.2"
+end

data/perf/benchmark.rb

@@ -0,0 +1,121 @@
+$: << 'lib'
+require 'benchmark'
+require 'rails'
+require 'active_record'
+require 'activerecord-import'
+require 'bullet'
+
+begin
+  require 'perftools'
+rescue LoadError
+  puts "Could not load perftools.rb, profiling won't be possible"
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :post
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :comments
+end
+
+# create database bullet_benchmark;
+ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'bullet_benchmark', :server => '/tmp/mysql.socket', :username => 'root')
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table)
+end
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :posts do |t|
+    t.column :title, :string
+    t.column :body, :string
+    t.column :user_id, :integer
+  end
+
+  create_table :comments do |t|
+    t.column :body, :string
+    t.column :post_id, :integer
+    t.column :user_id, :integer
+  end
+
+  create_table :users do |t|
+    t.column :name, :string
+  end
+end
+
+users_size = 100
+posts_size = 1000
+comments_size = 10000
+users = []
+users_size.times do |i|
+  users << User.new(:name => "user#{i}")
+end
+User.import users
+users = User.all
+
+posts = []
+posts_size.times do |i|
+  posts << Post.new(:title => "Title #{i}", :body => "Body #{i}", :user => users[i%100])
+end
+Post.import posts
+posts = Post.all
+
+comments = []
+comments_size.times do |i|
+  comments << Comment.new(:body => "Comment #{i}", :post => posts[i%1000], :user => users[i%100])
+end
+Comment.import comments
+
+puts "Start benchmarking..."
+
+
+Bullet.enable = true
+
+Benchmark.bm(70) do |bm|
+  bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
+    10.times do
+      Bullet.start_request
+      Post.select("SQL_NO_CACHE *").includes(:user, :comments => :user).each do |p|
+        p.title
+        p.user.name
+        p.comments.each do |c|
+          c.body
+          c.user.name
+        end
+      end
+      Bullet.end_request
+    end
+  end
+end
+
+puts "End benchmarking..."
+
+
+# Run benchmark with bundler
+#
+#     bundle exec ruby perf/benchmark.rb
+#
+# bullet 2.3.0 with rails 3.2.2
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       16.460000   0.190000  16.650000 ( 16.968246)
+#
+# bullet 2.3.0 with rails 3.1.4
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       14.600000   0.130000  14.730000 ( 14.937590)
+#
+# bullet 2.3.0 with rails 3.0.12
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       26.120000   0.430000  26.550000 ( 27.179304)
+#
+#
+# bullet 2.2.1 with rails 3.0.12
+#                                                                              user     system      total        real
+# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       29.970000   0.270000  30.240000 ( 30.452083)

data/rails/init.rb

@@ -0,0 +1 @@
+require 'bullet'

data/spec/bullet/detector/association_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe Association do
+      before :all do
+        @post1 = Post.first
+        @post2 = Post.last
+      end
+
+      context ".add_object_association" do
+        it "should add object, associations pair" do
+          Association.add_object_associations(@post1, :associations)
+          expect(Association.send(:object_associations)).to be_include(@post1.bullet_key, :associations)
+        end
+      end
+
+      context ".add_call_object_associations" do
+        it "should add call object, associations pair" do
+          Association.add_call_object_associations(@post1, :associations)
+          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_key, :associations)
+        end
+      end
+    end
+  end
+end

data/spec/bullet/detector/base_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe Base do
+    end
+  end
+end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Bullet
+  module Detector
+    describe CounterCache do
+      before :all do
+        @post1 = Post.first
+        @post2 = Post.last
+      end
+
+      context ".add_counter_cache" do
+        it "should create notification if conditions met" do
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(true)
+          expect(CounterCache).to receive(:create_notification).with("Post", [:comments])
+          CounterCache.add_counter_cache(@post1, [:comments])
+        end
+
+        it "should not create notification if conditions not met" do
+          expect(CounterCache).to receive(:conditions_met?).with(@post1.bullet_key, [:comments]).and_return(false)
+          expect(CounterCache).to receive(:create_notification).never
+          CounterCache.add_counter_cache(@post1, [:comments])
+        end
+      end
+
+      context ".add_possible_objects" do
+        it "should add possible objects" do
+          CounterCache.add_possible_objects([@post1, @post2])
+          expect(CounterCache.send(:possible_objects)).to be_include(@post1.bullet_key)
+          expect(CounterCache.send(:possible_objects)).to be_include(@post2.bullet_key)
+        end
+
+        it "should add impossible object" do
+          CounterCache.add_impossible_object(@post1)
+          expect(CounterCache.send(:impossible_objects)).to be_include(@post1.bullet_key)
+        end
+      end
+
+      context ".conditions_met?" do
+        it "should be true when object is possible, not impossible" do
+          CounterCache.add_possible_objects(@post1)
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq true
+        end
+
+        it "should be false when object is not possible" do
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+        end
+
+        it "should be true when object is possible, and impossible" do
+          CounterCache.add_possible_objects(@post1)
+          CounterCache.add_impossible_object(@post1)
+          expect(CounterCache.send(:conditions_met?, @post1.bullet_key, :associations)).to eq false
+        end
+      end
+    end
+  end
+end