flipsasser-bullet 1.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Richard Huang (flyerhzm@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,197 @@
+*Please note!* This is the Bullet gem as written by Richard Huang, with a few added niceties:
+
+- It has been refactored to support Rails initializers
+- Growl, console.log, and Rails.logger support have been added
+
+# Bullet #
+
+The Bullet plugin is designed to help you increase your application's performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries) or when you're using eager loading that isn't necessary.
+
+Best practice is to use Bullet while building your application, but UNINSTALL OR DEACTIVATE IT when you deploy to a production server. The last thing you want is your clients getting alerts about how lazy you are.
+
+## Installation ##
+
+### Get the source ##
+
+You can add Bullet to your Rails gem requirements:
+
+	config.gem 'flipsasser-bullet', :lib => nil, :source => 'http://gems.github.com'
+
+Or you can install it as a gem like so:
+
+	sudo gem install flipsasser-bullet --source http://gems.github.com
+
+Finally, you can install it as a Rails plugins:
+
+	ruby script/plugin install git://github.com/flipsasser/bullet.git
+
+### Configure Bullet ###
+
+Bullet boots up from a Rails initializer. It won't do ANYTHING unless you tell it to explicitly. Add a RAILS_ROOT/config/initializers/bullet.rb initializer with the following code:
+
+	# Only use Bullet in development...
+	if Bullet.enable = RAILS_ENV == 'development'
+		Bullet::Association.alert = true
+		Bullet::Association.bullet_logger = true  
+		Bullet::Association.console = true
+		Bullet::Association.growl = true
+		Bullet::Association.rails_logger = true
+	end
+
+The code above will enable all five of the Bullet notification systems:
+
+- `Bullet::Association.alert`: pop up a JavaScript alert in the browser
+- `Bullet::Association.bullet_logger`: log to the Bullet log file (RAILS_ROOT/log/bullet.log)
+- `Bullet::Association.rails_logger`: add warnings directly to the Rails log
+- `Bullet::Association.console`: log warnings to your browser's console.log (Safari/Webkit browsers or Firefox w/Firebug installed)
+- `Bullet::Association.growl`: pop up Growl warnings if your system has Growl installed. Requires a little bit of configuration
+
+### The Bullet log ###
+
+The Bullet log (log/bullet.log) will look something like this:
+
+	2009-08-25 20:40:17[INFO] N+1 Query: PATH_INFO: /posts;    model: Post => associations: [comments]·
+	Add to your finder: :include => [:comments]
+	2009-08-25 20:40:17[INFO] N+1 Query: method call stack:·
+	/Users/richard/Downloads/test/app/views/posts/index.html.erb:11:in `_run_erb_app47views47posts47index46html46erb'
+	/Users/richard/Downloads/test/app/views/posts/index.html.erb:8:in `each'
+	/Users/richard/Downloads/test/app/views/posts/index.html.erb:8:in `_run_erb_app47views47posts47index46html46erb'
+	/Users/richard/Downloads/test/app/controllers/posts_controller.rb:7:in `index'
+
+The first two lines are notifications that N+1 queries have been encountered. The remaining lines are stack traces so you can find exactly where the queries were invoked in your code, and fix them.
+
+Bullet also has a Rake task, `rake bullet:log:clear`, which will clear out the Bullet log.
+
+### Growl Support ###
+
+To get Growl support up-and-running for Bullet, follow the steps below:
+
+1. Install the ruby-growl gem: `sudo gem install ruby-growl`
+2. Open the Growl preference pane in Systems Preferences
+3. Click the "Network" tab
+4. Make sure both "Listen for incoming notifications" and "Allow remote application registration" are checked. *Note:* If you set a password, you will need to set `Bullet::Association.growl_password = 'your_growl_password'` in the initializer.
+5. Restart Growl ("General" tab -> Stop Growl -> Start Growl)
+6. Boot up your application. Bullet will automatically send a Growl notification when Growl is turned on. If you do not see it when your application loads, make sure it is enabled in your initializer and double-check the steps above.
+
+## Step by step example ##
+
+Bullet is designed to function as you browse through your application in development. It will alert you whenever it encounters N+1 queries or unused eager loading.
+
+*Important*: It is strongly recommended you disable your browser's cache.
+
+1. Setup your test environment
+
+	$ rails test
+	$ cd test
+	$ script/generate scaffold post name:string 
+	$ script/generate scaffold comment name:string post_id:integer
+	$ rake db:migrate
+
+2. Add relationships to `app/model/post.rb` and `app/model/comment.rb`
+
+	class Post < ActiveRecord::Base
+		has_many :comments
+	end
+
+	class Comment < ActiveRecord::Base
+		belongs_to :post
+	end
+
+3. Go to script/console and execute
+
+	post1 = Post.create(:name => 'first')
+	post2 = Post.create(:name => 'second')
+	post1.comments.create(:name => 'first')
+	post1.comments.create(:name => 'second')
+	post2.comments.create(:name => 'third')
+	post2.comments.create(:name => 'fourth')
+
+4. Change the `app/views/posts/index.html.erb` to produce an N+1 query
+
+	<% @posts.each do |post| %>
+		<tr>
+			<td><%= h post.name %></td>
+			<td><%= post.comments.collect(&:name) %></td>
+			<td><%= link_to 'Show', post %></td>
+			<td><%= link_to 'Edit', edit_post_path(post) %></td>
+			<td><%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %></td>
+		</tr>
+	<% end %>
+
+5. Install the Bullet plugin
+
+	$ script/plugin install git://github.com/flipsasser/bullet.git
+
+6. Enable the bullet plugin in development with a Rails initializer (RAILS_ROOT/config/intializers/bullet.rb):
+
+	if Bullet.enable = RAILS_ENV == 'development'
+		Bullet::Association.alert = true
+	end
+
+7. Boot up your development server
+
+	$ script/server 
+
+8. Visit http://localhost:3000/posts in your browser. Bullet will alert you that an N+1 query has occurred.
+
+	The request has N+1 queries as follows:
+	model: Post => associations: [comment]
+
+... which means there is an N+1 query from the Post object to the comments association.
+
+9. Fix the N+1 query. Change `app/controllers/posts_controller.rb`:
+
+	def index
+		@posts = Post.find(:all, :include => :comments)
+
+		respond_to do |format|
+			format.html # index.html.erb
+			format.xml  { render :xml => @posts }
+		end
+	end
+
+10. Refresh your browser. No alert should show up.
+
+This is because the original query, which read:
+
+	Post Load (1.0ms)   SELECT * FROM "posts" 
+	Comment Load (0.4ms)   SELECT * FROM "comments" WHERE ("comments".post_id = 1) 
+	Comment Load (0.3ms)   SELECT * FROM "comments" WHERE ("comments".post_id = 2) 
+
+... would cause one additional query for each post it found. The new SQL should look like this:
+
+	Post Load (0.5ms)   SELECT * FROM "posts" 
+	Comment Load (0.5ms)   SELECT "comments".* FROM "comments" WHERE ("comments".post_id IN (1,2)) 
+
+And your N+1 query is fixed. Cool!
+
+11. Now simulate unused eager loading. Change `app/controllers/posts_controller.rb` and `app/views/posts/index.html.erb`
+
+app/controllers/posts_controller.rb:
+
+	def index
+		@posts = Post.find(:all, :include => :comments)
+
+		respond_to do |format|
+			format.html # index.html.erb
+			format.xml  { render :xml => @posts }
+		end 
+	end 
+
+app/views/posts/index.html.erb:
+
+	<% @posts.each do |post| %>
+		<tr>
+			<td><%=h post.name %></td>
+			<td><%= link_to 'Show', post %></td>
+			<td><%= link_to 'Edit', edit_post_path(post) %></td>
+			<td><%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %></td>
+		</tr>
+	<% end %>
+
+12. Refresh your browser. Bullet will alert you that you have unused, eager-loaded objects.
+
+	The request has unused preload associations as follows:
+	model: Post => associations: [comment]
+
+Copyright (c) 2009 Richard Huang (flyerhzm@gmail.com), released under the MIT license.

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+require 'jeweler'
+
+desc 'Default: run unit tests.'
+task :default => :spec
+
+desc 'Generate documentation for the sitemap plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Bullet'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/spec_helper.rb', 'spec/**/*_spec.rb']
+end
+
+Jeweler::Tasks.new do |gemspec|
+  gemspec.name = "bullet"
+  gemspec.summary = "A plugin to kill N+1 queries and unused eager loading"
+  gemspec.description = "The Bullet plugin is designed to help you increase your application's performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries) or when you're using eager loading that isn't necessary."
+  gemspec.email = "flip@x451.com"
+  gemspec.homepage = "http://github.com/flipsasser/bullet"
+  gemspec.authors = ["Richard Huang", "Flip Sasser"]
+  gemspec.files.exclude '.gitignore'
+  gemspec.files.exclude 'log/'
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/bullet.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bullet}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Richard Huang", "Flip Sasser"]
+  s.date = %q{2009-08-27}
+  s.description = %q{The Bullet plugin is designed to help you increase your application's performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries) or when you're using eager loading that isn't necessary.}
+  s.email = %q{flip@x451.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "bullet.gemspec",
+     "lib/bullet.rb",
+     "lib/bullet/active_record.rb",
+     "lib/bullet/association.rb",
+     "lib/bullet/logger.rb",
+     "lib/bulletware.rb",
+     "rails/init.rb",
+     "spec/bullet_association_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/bullet_tasks.rake"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/flipsasser/bullet}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A plugin to kill N+1 queries and unused eager loading}
+  s.test_files = [
+    "spec/bullet_association_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/bullet.rb

@@ -0,0 +1,21 @@
+module Bullet
+  @@enable = nil
+
+  class <<self
+    def enable=(enable)
+      if enable != @@enable && @@enable = enable
+        Bullet::ActiveRecord.enable
+        ActionController::Dispatcher.middleware.use Bulletware
+      end
+      @@enable
+    end
+
+    def enable?
+      class_variables.include?('@@enable') and @@enable == true
+    end
+  end
+
+  autoload :ActiveRecord, 'bullet/active_record'
+  autoload :Association, 'bullet/association'
+  autoload :BulletLogger, 'bullet/logger'
+end

data/lib/bullet/active_record.rb

@@ -0,0 +1,62 @@
+module Bullet
+  module ActiveRecord
+    def self.enable
+      ::ActiveRecord::Base.class_eval do
+        class << self
+          alias_method :bullet_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 = bullet_find_every(options)
+
+            if records 
+              if records.size > 1
+                Bullet::Association.add_possible_objects(records)
+              elsif records.size == 1
+                Bullet::Association.add_impossible_object(records.first)
+              end
+            end
+
+            records
+          end
+
+          alias_method :bullet_preload_associations, :preload_associations
+          # add include for one to many associations query
+          def preload_associations(records, associations, preload_options={})
+            records = [records].flatten.compact.uniq
+            return if records.empty?
+            records.each do |record|
+              Bullet::Association.add_association(record, associations)
+            end
+            bullet_preload_associations(records, associations, preload_options={})
+          end
+
+          # define one to many associations
+          alias_method :bullet_collection_reader_method, :collection_reader_method
+          def collection_reader_method(reflection, association_proxy_class)
+            Bullet::Association.define_association(self, reflection.name)
+            bullet_collection_reader_method(reflection, association_proxy_class)
+          end
+        end
+      end
+
+      ::ActiveRecord::Associations::AssociationCollection.class_eval do
+        # call one to many associations
+        alias_method :bullet_load_target, :load_target
+        def load_target
+          Bullet::Association.call_association(@owner, @reflection.name)
+          bullet_load_target
+        end  
+      end
+      
+      ::ActiveRecord::Associations::AssociationProxy.class_eval do
+        # call has_one association
+        alias_method :bullet_load_target, :load_target
+        def load_target
+          Bullet::Association.call_association(@owner, @reflection.name)
+          bullet_load_target
+        end
+      end
+    end
+  end
+end

data/lib/bullet/association.rb

@@ -0,0 +1,277 @@
+module Bullet
+  class BulletAssociationError < StandardError
+  end
+
+  class Association
+    class <<self
+      @@alert = nil
+      @@bullet_logger = nil
+      @@console = nil
+      @@growl = nil
+      @@growl_password = nil
+      @@rails_logger = nil
+
+      def start_request
+        # puts "start request"
+      end
+
+      def end_request
+        # puts "end request"
+        @@object_associations = nil
+        @@unpreload_associations = nil
+        @@unused_preload_associations = nil
+        @@callers = nil
+        @@possible_objects = nil
+        @@impossible_objects = nil
+        @@call_object_associations = nil
+      end
+
+      def alert=(alert)
+        @@alert = alert
+      end
+
+      def bullet_logger=(bullet_logger)
+        if @@bullet_logger = bullet_logger
+          @@logger_file = File.open(Bullet::BulletLogger::LOG_FILE, 'a+')
+          @@logger = Bullet::BulletLogger.new(@@logger_file)
+        end
+      end
+
+      def console=(console)
+        @@console = console
+      end
+
+      def growl=(growl)
+        if growl
+          begin
+            require 'ruby-growl'
+            growl = Growl.new('localhost', 'ruby-growl', ['Bullet Notification'], nil, @@growl_password)
+            growl.notify('Bullet Notification', 'Bullet Notification', 'Bullet Growl notifications have been turned on')
+          rescue MissingSourceFile
+            raise BulletAssociationError.new('You must install the ruby-growl gem to use Growl notifications: `sudo gem install ruby-growl`')
+          end
+        end
+        @@growl = growl
+      end
+
+      def growl_password=(growl_password)
+        @@growl_password = growl_password
+      end
+
+      def rails_logger=(rails_logger)
+        @@rails_logger = rails_logger
+      end
+
+      def check_unused_preload_associations
+        object_associations.each do |object, association|
+          call_object_association = call_object_associations[object] || []
+          add_unused_preload_associations(object.class, association - call_object_association) unless (association - call_object_association).empty?
+        end
+      end
+      
+      def has_bad_assocations?
+        check_unused_preload_associations
+        has_unpreload_associations? or has_unused_preload_associations?
+      end
+
+      def has_unused_preload_associations?
+        !unused_preload_associations.empty?
+      end
+      
+      def has_unpreload_associations?
+        !unpreload_associations.empty?
+      end
+
+      def bad_associations_alert
+        str = ''
+        if @@alert || @@console || @@growl
+          response = []
+          if has_unused_preload_associations?
+            response.push("Unused preload associations detected:\n")
+            response.push(*@@unused_preload_associations.to_a.collect{|klazz, associations| klazz_associations_str(klazz, associations)}.join('\n'))
+          end
+          if has_unpreload_associations?
+            response.push("#{"\n" unless response.empty?}N+1 queries detected:\n")
+            response.push(*@@unpreload_associations.to_a.collect{|klazz, associations| "  #{klazz} => [#{associations.map(&:inspect).join(', ')}]"}.join('\n'))
+          end
+        end
+        if @@alert
+          str << wrap_js_association("alert(#{response.join("\n").inspect});")
+        end
+        if @@console
+          str << wrap_js_association("if (typeof(console) != 'undefined' && console.log) console.log(#{response.join("\n").inspect});")
+        end
+        if @@growl
+          begin
+            growl = Growl.new('localhost', 'ruby-growl', ['Bullet Notification'], nil, @@growl_password)
+            growl.notify('Bullet Notification', 'Bullet Notification', response.join("\n"))
+          rescue
+          end
+          str << '<!-- Sent Growl notification -->'
+        end
+        str
+      end
+
+      def wrap_js_association(message)
+        str = ''
+        str << "<script type=\"text/javascript\">/*<![CDATA[*/"
+        str << message
+        str << "/*]]>*/</script>\n"
+      end
+
+      def log_bad_associations(path)
+        if (@@bullet_logger || @@rails_logger) && (!unpreload_associations.empty? || !unused_preload_associations.empty?)
+          Rails.logger.warn '' if @@rails_logger
+          unused_preload_associations.each do |klazz, associations|
+            log = ["Unused preload associations: #{path}", klazz_associations_str(klazz, associations), "  Remove from your finder: #{associations_str(associations)}"].join("\n")
+            @@logger.info(log) if @@bullet_logger
+            Rails.logger.warn(log) if @@rails_logger
+          end
+          unpreload_associations.each do |klazz, associations|
+            log = ["N+1 Query in #{path}", klazz_associations_str(klazz, associations), "  Add to your finder: #{associations_str(associations)}"].join("\n")
+            @@logger.info(log) if @@bullet_logger
+            Rails.logger.warn(log) if @@rails_logger
+          end  
+          callers.each do |c|
+            log = ["N+1 Query method call stack", c.map{|line| "  #{line}"}].flatten.join("\n")
+            @@logger.info(log) if @@bullet_logger
+            Rails.logger.warn(log) if @@rails_logger
+          end
+          @@logger_file.flush if @@bullet_logger
+        end
+      end
+      
+      def bad_associations_str(bad_associations)
+        # puts bad_associations.inspect
+        bad_associations.to_a.collect{|klazz, associations| klazz_associations_str(klazz, associations)}.join('\\n')
+      end
+      
+      def klazz_associations_str(klazz, associations)
+        "  #{klazz} => [#{associations.map(&:inspect).join(', ')}]"
+      end
+      
+      def associations_str(associations)
+        ":include => #{associations.map{|a| a.to_sym unless a.is_a? Hash}.inspect}"
+      end
+
+      def has_klazz_association(klazz)
+        !klazz_associations[klazz].nil? and klazz_associations.keys.include?(klazz)
+      end
+      
+      def define_association(klazz, associations)
+        # puts "define association, #{klazz} => #{associations.inspect}"
+        add_klazz_associations(klazz, associations)
+      end
+
+      def call_association(object, associations)
+        # puts "call association, #{object} => #{associations.inspect}"
+        add_call_object_associations(object, associations)
+        if unpreload_associations?(object, associations)
+          add_unpreload_associations(object.class, associations)
+          caller_in_project
+        end
+      end
+      
+      def unpreload_associations?(object, associations)
+        klazz = object.class
+        (!possible_objects[klazz].nil? and possible_objects[klazz].include?(object)) and 
+        (impossible_objects[klazz].nil? or !impossible_objects[klazz].include?(object)) and 
+        (object_associations[object].nil? or !object_associations[object].include?(associations))
+      end
+
+      def add_unpreload_associations(klazz, associations)
+        # puts "add unpreload associations, #{klazz} => #{associations.inspect}"
+        unpreload_associations[klazz] ||= []
+        unpreload_associations[klazz] << associations
+        unique(unpreload_associations[klazz])
+      end
+      
+      def add_unused_preload_associations(klazz, associations)
+        # puts "add unused preload associations, #{klazz} => #{associations.inspect}"
+        unused_preload_associations[klazz] ||= []
+        unused_preload_associations[klazz] << associations
+        unique(unused_preload_associations[klazz])
+      end
+
+      def add_association(object, associations)
+        # puts "add associations, #{object} => #{associations.inspect}"
+        object_associations[object] ||= []
+        object_associations[object] << associations
+        unique(object_associations[object])
+      end
+
+      def add_call_object_associations(object, associations)
+        # puts "add call object associations, #{object} => #{associations.inspect}"
+        call_object_associations[object] ||= []
+        call_object_associations[object] << associations
+        unique(call_object_associations[object])
+      end
+
+      def add_possible_objects(objects)
+        # puts "add possible objects, #{objects.inspect}"
+        klazz= objects.first.class
+        possible_objects[klazz] ||= []
+        possible_objects[klazz] << objects
+        unique(possible_objects[klazz])
+      end
+
+      def add_impossible_object(object)
+        # puts "add impossible object, #{object}"
+        klazz = object.class
+        impossible_objects[klazz] ||= []
+        impossible_objects[klazz] << object
+        impossible_objects[klazz].uniq!
+      end
+      
+      def add_klazz_associations(klazz, associations)
+        # puts "define associations, #{klazz} => #{associations.inspect}"
+        klazz_associations[klazz] ||= []
+        klazz_associations[klazz] << associations
+        unique(klazz_associations[klazz])
+      end
+      
+      def unique(array)
+        array.flatten!
+        array.uniq!
+      end
+      
+      def unpreload_associations
+        @@unpreload_associations ||= {}
+      end
+      
+      def unused_preload_associations
+        @@unused_preload_associations ||= {}
+      end
+      
+      def object_associations
+        @@object_associations ||= {}
+      end
+      
+      def call_object_associations
+        @@call_object_associations ||= {}
+      end
+      
+      def possible_objects
+        @@possible_objects ||= {}
+      end
+
+      def impossible_objects
+        @@impossible_objects ||= {}
+      end
+      
+      def klazz_associations
+        @@klazz_associations ||= {}
+      end
+      
+      VENDOR_ROOT = File.join(RAILS_ROOT, 'vendor')
+      def caller_in_project
+        callers << caller.select {|c| c =~ /#{RAILS_ROOT}/}.reject {|c| c =~ /#{VENDOR_ROOT}/}
+        callers.uniq!
+      end
+      
+      def callers
+        @@callers ||= []
+      end
+    end
+  end
+end