timcharper-spork 0.4.4 → 0.5.0

data/features/diagnostic_mode.feature

@@ -0,0 +1,37 @@
+Feature: Diagnostic Mode
+  To help a developer quickly pinpoint why files are being loaded
+  Spork provides a diagnostic mode
+  That provides a list of which project files were loaded during prefork, and who loaded them.
+
+  Scenario: Running spork --diagnose
+    Given I am in the directory "test_project"
+    And a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+
+      Spork.prefork do
+        require 'lib/awesome.rb'
+        require '../external_dependency/super_duper.rb'
+      end
+
+      Spork.each_run do
+        puts "I'm loading the stuff just for this run..."
+      end
+      """
+    And a file named "lib/awesome.rb" with:
+      """
+      class Awesome
+      end
+      """
+    And a file named "../external_dependency/super_duper.rb" with:
+      """
+      class Awesome
+      end
+      """
+    When I run spork --diagnose
+    Then the output should contain "lib/awesome.rb"
+    And the output should contain "spec/spec_helper.rb:5"
+    And the output should not contain "super_duper.rb"
+    And the output should not contain "diagnose.rb"
+     

data/features/rails_integration.feature

@@ -0,0 +1,77 @@
+Feature: Rails Integration
+  To get a developer up and running quickly
+  Spork automatically integrates with rails
+  Providing default hooks and behaviors
+
+  Background: Rails App with RSpec and Spork
+
+    Given I am in a fresh rails project named "test_rails_project"
+    And a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+      require 'spec'
+
+      Spork.prefork do
+        $run_phase = :prefork
+        require File.dirname(__FILE__) + '/../config/environment.rb'
+      end
+
+      Spork.each_run do
+        $run_phase = :each_run
+        puts "I'm loading the stuff just for this run..."
+      end
+      
+      class ActiveRecord::Base
+        class << self
+          def establish_connection
+            ($loaded_stuff ||= []) << 'establish_connection'
+            puts "Database connection was automatically re-established!"
+          end
+        end
+      end
+      """
+    And a file named "app/models/user.rb" with:
+      """
+      class User < ActiveRecord::Base
+        ($loaded_stuff ||= []) << 'User'
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """
+      module ApplicationHelper
+        ($loaded_stuff ||= []) << 'ApplicationHelper'
+      end
+      """
+    And a file named "app/models/user_observer.rb" with:
+      """
+      class UserObserver < ActiveRecord::Observer
+        ($loaded_stuff ||= []) << 'UserObserver'
+      end
+      """
+    And a file named "spec/models/user_spec.rb" with:
+      """
+      describe User do
+        it "does absoluately nothing" do
+          Spork.state.should == :using_spork
+          $loaded_stuff.should include('establish_connection')
+          $loaded_stuff.should include('User')
+          $loaded_stuff.should include('UserObserver')
+          $loaded_stuff.should include('ApplicationHelper')
+          puts "Specs successfully run within spork, and all initialization files were loaded"
+        end
+      end
+      """
+  Scenario: Analyzing files were preloaded
+    When I run spork --diagnose
+    Then the output should not contain "user_observer.rb"
+    Then the output should not contain "user.rb"
+    Then the output should not contain "app/controllers/application.rb"
+    Then the output should not contain "app/controllers/application_controller.rb"
+    Then the output should not contain "app/controllers/application_helper.rb"
+  
+  Scenario: Running spork with a rails app and observers
+  
+    When I fire up a spork instance with "spork rspec"
+    And I run spec --drb spec/models/user_spec.rb 
+    Then the output should contain "Specs successfully run within spork, and all initialization files were loaded"

data/features/steps/rails_steps.rb

@@ -0,0 +1,5 @@
+Given /^I am in a fresh rails project named "(.+)"$/ do |folder_name|
+  @current_dir = SporkWorld::SANDBOX_DIR
+  run("#{SporkWorld::RUBY_BINARY} #{%x{which rails}.chomp} #{folder_name}")
+  @current_dir = File.join(File.join(SporkWorld::SANDBOX_DIR, folder_name))
+end

data/features/steps/sandbox_steps.rb

@@ -0,0 +1,60 @@
+Given /^I am in the directory "(.*)"$/ do |sandbox_dir_relative_path|
+  path = File.join(SporkWorld::SANDBOX_DIR, sandbox_dir_relative_path)
+  FileUtils.mkdir_p(path)
+  @current_dir = File.join(path)
+end
+
+Given /^a file named "([^\"]*)"$/ do |file_name|
+  create_file(file_name, '')
+end
+
+Given /^a file named "([^\"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+When /^I run (spork|spec)($| .*$)/ do |command, spork_opts|
+  if command == 'spork'
+    command = SporkWorld::BINARY
+  else
+    command = %x{which #{command}}.chomp
+  end
+  run "#{SporkWorld::RUBY_BINARY} #{command} #{spork_opts}"
+end
+
+When /^I fire up a spork instance with "spork(.*)"$/ do |spork_opts|
+  run_in_background "#{SporkWorld::RUBY_BINARY} #{SporkWorld::BINARY} #{spork_opts}"
+  output = ""
+  begin
+    status = Timeout::timeout(15) do
+      # Something that should be interrupted if it takes too much time...
+      while line = @bg_stderr.gets
+        output << line
+        puts line
+        break if line.include?("Spork is ready and listening")
+      end
+    end
+  rescue Timeout::Error
+    puts "I can't seem to launch Spork properly.  Output was:\n#{output}"
+    true.should == false
+  end
+end
+
+Then /^the output should contain$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^the output should contain "(.+)"$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^the output should not contain$/ do |text|
+  last_stdout.should_not include(text)
+end
+
+Then /^the output should not contain "(.+)"$/ do |text|
+  last_stdout.should_not include(text)
+end
+
+Then /^the output should be$/ do |text|
+  last_stdout.should == text
+end

data/features/support/env.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'fileutils'
+require 'forwardable'
+require 'tempfile'
+require 'spec/expectations'
+require 'timeout'
+
+class SporkWorld
+  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/spork')
+  SANDBOX_DIR   = File.expand_path(File.join(File.dirname(__FILE__), '../../tmp/sandbox'))
+  
+  extend Forwardable
+  def_delegators SporkWorld, :sandbox_dir, :spork_lib_dir
+
+  def spork_lib_dir
+    @spork_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+
+  def initialize
+    @current_dir = SANDBOX_DIR
+    @background_jobs = []
+  end
+
+  private
+  attr_reader :last_exit_status, :last_stderr, :last_stdout, :background_jobs
+
+  def create_file(file_name, file_content)
+    file_content.gsub!("SPORK_LIB", "'#{spork_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
+    in_current_dir do
+      FileUtils.mkdir_p(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+
+  def run(command)
+    stderr_file = Tempfile.new('spork')
+    stderr_file.close
+    in_current_dir do
+      @last_stdout = `#{command} 2> #{stderr_file.path}`
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+  def run_in_background(command)
+    child_stdin, parent_stdin = IO::pipe
+    parent_stdout, child_stdout = IO::pipe
+    parent_stderr, child_stderr = IO::pipe
+    
+    background_jobs << Kernel.fork do
+      # grandchild
+      [parent_stdin, parent_stdout, parent_stderr].each { |io| io.close }
+      
+      STDIN.reopen(child_stdin)
+      STDOUT.reopen(child_stdout)
+      STDERR.reopen(child_stderr)
+      
+      [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+
+      in_current_dir do
+        exec command
+      end
+    end
+    
+    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+    parent_stdin.sync = true
+    
+    @bg_stdin, @bg_stdout, @bg_stderr = [parent_stdin, parent_stdout, parent_stderr]
+  end
+
+  def terminate_background_jobs
+    if @background_jobs
+      @background_jobs.each do |pid|
+        Process.kill(Signal.list['TERM'], pid)
+      end
+    end
+  end
+
+end
+
+World do
+  SporkWorld.new
+end
+
+Before do
+  FileUtils.rm_rf SporkWorld::SANDBOX_DIR
+  FileUtils.mkdir_p SporkWorld::SANDBOX_DIR
+end
+
+After do
+  # FileUtils.rm_rf SporkWorld::SANDBOX_DIR
+  terminate_background_jobs
+end

data/lib/spork/app_framework/rails.rb

@@ -0,0 +1,113 @@
+class Spork::AppFramework::Rails < Spork::AppFramework
+  
+  # TODO - subclass this out to handle different versions of rails
+  class NinjaPatcher
+    def self.run
+      install_hook
+    end
+    
+    def self.install_hook
+      ::Rails::Initializer.class_eval do
+        alias :require_frameworks_without_spork :require_frameworks unless method_defined?(:require_frameworks_without_spork)
+        def require_frameworks
+          result = require_frameworks_without_spork
+          Spork::AppFramework[:Rails].ninja_patcher.install_specific_hooks
+          result
+        end
+      end
+    end
+    
+    def self.install_specific_hooks
+      auto_reestablish_db_connection
+      delay_observer_loading
+      delay_app_preload
+      delay_application_controller_loading
+    end
+    
+    def self.delay_observer_loading
+      if Object.const_defined?(:ActiveRecord)
+        Spork.trap_method(::ActiveRecord::Observing::ClassMethods, :instantiate_observers)
+      end
+      if Object.const_defined?(:ActionController)
+        require "action_controller/dispatcher.rb"
+        Spork.trap_class_method(::ActionController::Dispatcher, :define_dispatcher_callbacks)
+      end
+    end
+    
+    def self.delay_app_preload
+      if ::Rails::Initializer.instance_methods.include?('load_application_classes')
+        Spork.trap_method(::Rails::Initializer, :load_application_classes)
+      end
+    end
+    
+    def self.delay_application_controller_loading
+      if application_controller_source = ["#{Dir.pwd}/app/controllers/application.rb", "#{Dir.pwd}/app/controllers/application_controller.rb"].find { |f| File.exist?(f) }
+        application_helper_source = "#{Dir.pwd}/app/helpers/application_helper.rb"
+        load_paths = (Object.const_defined?(:Dependencies) ? ::Dependencies : ::ActiveSupport::Dependencies).load_paths
+        load_paths.unshift(File.expand_path('rails_stub_files', File.dirname(__FILE__)))
+        Spork.each_run do
+          require application_controller_source
+          require application_helper_source if File.exist?(application_helper_source)
+        end
+      end
+    end
+    
+    def self.auto_reestablish_db_connection
+      if Object.const_defined?(:ActiveRecord)
+        Spork.each_run do
+          ActiveRecord::Base.establish_connection
+        end
+      end
+    end
+  end
+  
+  def bootstrap_required?
+    false
+  end
+  
+  def preload(&block)
+    STDERR.puts "Preloading Rails environment"
+    STDERR.flush
+    ENV["RAILS_ENV"] ||= 'test'
+    preload_rails
+    require environment_file
+    yield
+  end
+  
+  def environment_file
+    @environment_file ||= File.expand_path("config/environment.rb", Dir.pwd)
+  end
+  
+  def boot_file
+    @boot_file ||= File.join(File.dirname(environment_file), 'boot')
+  end
+  
+  def environment_contents
+    @environment_contents ||= File.read(environment_file)
+  end
+  
+  def vendor
+    @vendor ||= File.expand_path("vendor/rails", Dir.pwd)
+  end
+  
+  def version
+    @version ||= (
+      if /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/.match(environment_contents)
+        $1
+      else
+        nil
+      end
+    )
+  end
+  
+  def ninja_patcher
+    ::Spork::AppFramework::Rails::NinjaPatcher
+  end
+  
+  def preload_rails
+    Object.const_set(:RAILS_GEM_VERSION, version) if version
+    require boot_file
+    ninja_patcher.run
+  end
+  
+end

data/lib/spork/app_framework/rails_stub_files/application.rb

@@ -0,0 +1,2 @@
+class ::ApplicationController < ActionController::Base
+end

data/lib/spork/app_framework/rails_stub_files/application_controller.rb

@@ -0,0 +1,2 @@
+class ::ApplicationController < ActionController::Base
+end

data/lib/spork/app_framework/rails_stub_files/application_helper.rb

@@ -0,0 +1,2 @@
+module ::ApplicationHelper
+end

data/lib/spork/app_framework/unknown.rb

@@ -0,0 +1,6 @@
+class Spork::AppFramework::Unknown < Spork::AppFramework
+  def bootstrap_required?
+    true
+  end
+  
+end

data/lib/spork/app_framework.rb

@@ -0,0 +1,46 @@
+class Spork::AppFramework
+  SUPPORTED_FRAMEWORKS = {
+    :Rails => lambda do
+      File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
+    end
+  }
+  
+  def self.detect_framework_name
+    SUPPORTED_FRAMEWORKS.each do |key, value|
+      return key if value.call
+    end
+    :Unknown
+  end
+  
+  def self.detect_framework
+    name = detect_framework_name
+    self[name]
+  end
+  
+  def self.[](name)
+    instances[name] ||= (
+      require File.join(File.dirname(__FILE__), "app_framework", name.to_s.downcase)
+      const_get(name).new
+    )
+  end
+  
+  def self.instances
+    @instances ||= {}
+  end
+  
+  def self.short_name
+    name.gsub('Spork::AppFramework::', '')
+  end
+  
+  def bootstrap_required?
+    raise NotImplemented
+  end
+  
+  def preload(&block)
+    yield
+  end
+  
+  def name
+    self.class.short_name
+  end
+end

data/lib/spork/custom_io_streams.rb

@@ -0,0 +1,23 @@
+module Spork::CustomIOStreams
+  def self.included(klass)
+    klass.send(:extend, ::Spork::CustomIOStreams::ClassMethods)
+  end
+  
+  def stderr
+    self.class.stderr
+  end
+
+  def stdout
+    self.class.stdout
+  end
+  
+  module ClassMethods
+    def stderr
+      $stderr
+    end
+  
+    def stdout
+      $stdout
+    end
+  end
+end

data/lib/spork/diagnoser.rb

@@ -0,0 +1,72 @@
+class Spork::Diagnoser
+  class << self
+    def loaded_files
+      @loaded_files ||= {}
+    end
+    
+    def install_hook!(dir = Dir.pwd)
+      @dir = File.expand_path(Dir.pwd, dir)
+      
+      Kernel.class_eval do
+        alias :require_without_diagnoser :require
+        alias :load_without_diagnoser :load
+        
+        def require(string)
+          ::Spork::Diagnoser.add_included_file(string, caller)
+          require_without_diagnoser(string)
+        end
+        
+        def load(string)
+          ::Spork::Diagnoser.add_included_file(string, caller)
+          load_without_diagnoser(string)
+        end
+      end
+    end
+    
+    def add_included_file(filename, callstack)
+      filename = expand_filename(filename)
+      return unless File.exist?(filename)
+      loaded_files[filename] = caller.select { |f| ! f.include?('lib/spork/diagnoser.rb')} if subdirectory?(filename)
+    end
+    
+    def expand_filename(filename)
+      ([Dir.pwd] + $:).each do |attempted_path|
+        attempted_filename = File.expand_path(filename, attempted_path)
+        return attempted_filename if File.file?(attempted_filename)
+        attempted_filename = attempted_filename + ".rb"
+        return attempted_filename if File.file?(attempted_filename)
+      end
+      filename
+    end
+    
+    def subdirectory?(directory)
+      File.expand_path(directory, Dir.pwd).include?(@dir)
+    end
+    
+    def remove_hook!
+      return unless Kernel.private_instance_methods.include?('require_without_diagnoser')
+      Kernel.class_eval do
+        alias :require :require_without_diagnoser
+        alias :load :load_without_diagnoser
+        
+        undef_method(:require_without_diagnoser)
+        undef_method(:load_without_diagnoser)
+      end
+      true
+    end
+    
+    def output_results(stdout)
+      project_prefix = Dir.pwd + "/"
+      minimify = lambda { |f| f.gsub(project_prefix, '')}
+      stdout.puts "- Spork Diagnosis -\n"
+      stdout.puts "-- Summary --"
+      stdout.puts loaded_files.keys.sort.map(&minimify)
+      stdout.puts "\n\n\n"
+      stdout.puts "-- Detail --"
+      loaded_files.keys.sort.each do |file|
+        stdout.puts "\n\n\n--- #{minimify.call(file)} ---\n"
+        stdout.puts loaded_files[file].map(&minimify)
+      end
+    end
+  end
+end

data/lib/spork/runner.rb

@@ -19,6 +19,7 @@ module Spork
       
       opt.separator "Options:"
       opt.on("-b", "--bootstrap")  {|ignore| @options[:bootstrap] = true }
+      opt.on("-d", "--diagnose")  {|ignore| @options[:diagnose] = true }
       opt.on("-h", "--help")  {|ignore| @options[:help] = true }
       non_option_args = args.select { |arg| ! args[0].match(/^-/) }
       @options[:server_matcher] = non_option_args[0]
@@ -45,7 +46,7 @@ module Spork
       if options[:server_matcher]
         @server = Spork::Server.supported_servers(options[:server_matcher]).first
         unless @server
-          @output.puts <<-ERROR
+          @error.puts <<-ERROR
 #{options[:server_matcher].inspect} didn't match a supported test framework.
 
 #{supported_servers_text}
@@ -54,7 +55,7 @@ module Spork
         end
         
         unless @server.available?
-          @output.puts  <<-USEFUL_ERROR
+          @error.puts  <<-USEFUL_ERROR
 I can't find the helper file #{@server.helper_file} for the #{@server.server_name} testing framework.
 Are you running me from the project directory?
           USEFUL_ERROR
@@ -63,7 +64,7 @@ Are you running me from the project directory?
       else
         @server = Spork::Server.available_servers.first
         if @server.nil?
-          @output.puts  <<-USEFUL_ERROR
+          @error.puts  <<-USEFUL_ERROR
 I can't find any testing frameworks to use.
 Are you running me from a project directory?
           USEFUL_ERROR
@@ -76,12 +77,26 @@ Are you running me from a project directory?
     def run
       return false unless find_server
       ENV["DRB"] = 'true'
-      ENV["RAILS_ENV"] ||= 'test' if server.using_rails?
-      @output.puts "Using #{server.server_name}"
-      return server.bootstrap if options[:bootstrap]
-      return(false) unless server.preload
-      server.run
-      return true
+      @error.puts "Using #{server.server_name}"
+      @error.flush
+      case
+      when options[:bootstrap]
+        server.bootstrap
+      when options[:diagnose]
+        require 'spork/diagnoser'
+        
+        Spork::Diagnoser.install_hook!
+        server.preload
+        Spork::Diagnoser.output_results(@output)
+        return true
+      else
+        return(false) unless server.preload
+        server.run
+        return true
+      end
+    end
+    
+    def diagnose
     end
 
     private

data/lib/spork/server.rb

@@ -1,6 +1,8 @@
 require 'drb/drb'
 require 'rbconfig'
 require 'spork/forker.rb'
+require 'spork/custom_io_streams.rb'
+require 'spork/app_framework.rb'
 
 # This is based off of spec_server.rb from rspec-rails (David Chelimsky), which was based on Florian Weber's TDDMate
 class Spork::Server
@@ -9,6 +11,8 @@ class Spork::Server
   LOAD_PREFERENCE = ['RSpec', 'Cucumber']
   BOOTSTRAP_FILE = File.dirname(__FILE__) + "/../../assets/bootstrap.rb"
   
+  include Spork::CustomIOStreams
+  
   def self.port
     raise NotImplemented
   end
@@ -45,20 +49,16 @@ class Spork::Server
     LOAD_PREFERENCE.index(server_name) || LOAD_PREFERENCE.length
   end
   
-  def self.using_rails?
-    File.exist?("config/environment.rb")
-  end
-  
   def self.bootstrapped?
     File.read(helper_file).include?("Spork.prefork")
   end
   
   def self.bootstrap
     if bootstrapped?
-      puts "Already bootstrapped!"
+      stderr.puts "Already bootstrapped!"
       return
     end
-    puts "Bootstrapping #{helper_file}."
+    stderr.puts "Bootstrapping #{helper_file}."
     contents = File.read(helper_file)
     bootstrap_code = File.read(BOOTSTRAP_FILE)
     File.open(helper_file, "wb") do |f|
@@ -66,7 +66,7 @@ class Spork::Server
       f.puts contents
     end
     
-    puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
+    stderr.puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
     true
   end
   
@@ -80,7 +80,8 @@ class Spork::Server
     trap("SIGTERM") { abort; exit!(0) }
     trap("USR2") { abort; restart } if Signal.list.has_key?("USR2")
     DRb.start_service("druby://127.0.0.1:#{port}", self)
-    puts "Spork is ready and listening on #{port}!"
+    stderr.puts "Spork is ready and listening on #{port}!"
+    stderr.flush
     DRb.thread.join
   end
   
@@ -94,9 +95,10 @@ class Spork::Server
   
   def run(argv, stderr, stdout)
     return false if running?
+    
     @child = ::Spork::Forker.new do
       $stdout, $stderr = stdout, stderr
-      Spork.exec_each_run(helper_file)
+      Spork.exec_each_run { load helper_file }
       run_tests(argv, stderr, stdout)
     end
     @child.result
@@ -107,20 +109,30 @@ class Spork::Server
   end
   
   private
+    def self.framework
+      @framework ||= Spork::AppFramework.detect_framework
+    end
+    
     def self.preload
-      if bootstrapped?
-        puts "Loading Spork.prefork block..."
-        Spork.exec_prefork(helper_file)
-      else
-        puts "#{helper_file} has not been sporked.  Run spork --bootstrap to do so."
-        # are we in a rails app?
-        if using_rails?
-          puts "Preloading Rails environment"
-          require "config/environment.rb"
-        else
-          puts "There's nothing I can really do for you.  Bailing."
-          return false
+      Spork.exec_prefork do
+        unless bootstrapped?
+          stderr.puts "#{helper_file} has not been bootstrapped.  Run spork --bootstrap to do so."
+          stderr.flush
+        
+          if framework.bootstrap_required?
+            stderr.puts "I can't do anything for you by default for the framework your using: #{framework.short_name}.\nYou must bootstrap #{helper_file} to continue."
+            stderr.flush
+            return false
+          end
         end
+      
+        framework.preload do
+          if bootstrapped?
+            stderr.puts "Loading Spork.prefork block..."
+            stderr.flush
+            load(helper_file)
+          end
+        end  
       end
       true
     end
@@ -130,7 +142,8 @@ class Spork::Server
     end
     
     def restart
-      puts "restarting"
+      stderr.puts "restarting"
+      stderr.flush
       config       = ::Config::CONFIG
       ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
       command_line = [ruby, $0, ARGV].flatten.join(' ')
@@ -144,7 +157,8 @@ class Spork::Server
     def sig_int_received
       if running?
         abort
-        puts "Running tests stopped.  Press CTRL-C again to stop the server."
+        stderr.puts "Running tests stopped.  Press CTRL-C again to stop the server."
+        stderr.flush
       else
         exit!(0)
       end

data/lib/spork.rb

@@ -1,46 +1,51 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 module Spork
   class << self
-    def already_preforked
-      @already_preforked ||= []
+    def already_ran
+      @already_ran ||= []
     end
     
-    def already_run
-      @already_run ||= []
+    def each_run_procs
+      @each_run_procs ||= []
     end
     
     def prefork(&block)
-      return if already_preforked.include?(expanded_caller(caller.first))
-      already_preforked << expanded_caller(caller.first)
+      return if already_ran?(caller.first)
       yield
     end
-  
+    
     def each_run(&block)
-      return if @state == :preforking || (@state != :not_using_spork && already_run.include?(expanded_caller(caller.first)))
-      already_run << expanded_caller(caller.first)
-      yield
+      return if already_ran?(caller.first)
+      if @state == :using_spork
+        each_run_procs << block
+      else
+        yield
+      end
     end
-  
-    def preforking!
-      @state = :preforking
+    
+    def already_ran?(caller_script_and_line)
+      return true if already_ran.include?(expanded_caller(caller_script_and_line))
+      already_ran << expanded_caller(caller_script_and_line)
+      false
     end
-  
-    def running!
-      @state = :running
+    
+    def using_spork!
+      @state = :using_spork
     end
-  
+    
     def state
       @state ||= :not_using_spork
     end
-  
-    def exec_prefork(helper_file)
-      preforking!
-      load(helper_file)
+    
+    def exec_prefork(&block)
+      using_spork!
+      yield
     end
-  
-    def exec_each_run(helper_file)
-      running!
-      load(helper_file)
+    
+    def exec_each_run(&block)
+      each_run_procs.each { |p| p.call }
+      each_run_procs.clear
+      yield if block_given?
     end
     
     def expanded_caller(caller_line)
@@ -48,5 +53,29 @@ module Spork
       line.gsub(/:.+/, '')
       File.expand_path(Dir.pwd, file) + ":" + line
     end
+    
+    def trap_method(klass, method_name)
+      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
+        alias :#{method_name}_without_spork :#{method_name} unless method_defined?(:#{method_name}_without_spork) 
+        def #{method_name}(*args)
+          Spork.each_run_procs << lambda do
+            #{method_name}_without_spork(*args)
+          end
+        end
+      EOF
+    end
+    
+    def trap_class_method(klass, method_name)
+      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
+        class << self
+          alias :#{method_name}_without_spork :#{method_name} unless method_defined?(:#{method_name}_without_spork)
+          def #{method_name}(*args)
+            Spork.each_run_procs << lambda do
+              #{method_name}_without_spork(*args)
+            end
+          end
+        end
+      EOF
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,20 +1,102 @@
 require 'rubygems'
 require 'spec'
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-SPEC_TMP_DIR = File.dirname(__FILE__) + "/tmp"
-require 'spork'
-require 'spork/runner.rb'
-require 'spork/server.rb'
-require 'stringio'
-
-Spec::Runner.configure do |config|
-  config.before(:each) do
-    $test_stdout = StringIO.new
+unless $spec_helper_loaded
+  $spec_helper_loaded = true
+
+  $LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+  SPEC_TMP_DIR = File.expand_path('tmp', File.dirname(__FILE__))
+  
+  require 'spork'
+  require 'spork/runner.rb'
+  require 'spork/server.rb'
+  require 'spork/diagnoser.rb'
+  require 'stringio'
+  require 'fileutils'
+
+  Spec::Runner.configure do |config|
+    config.before(:each) do
+      $test_stdout = StringIO.new
+      $test_stderr = StringIO.new
+    end
+  
+    config.after(:each) do
+      FileUtils.rm_rf(SPEC_TMP_DIR) if File.directory?(SPEC_TMP_DIR)
+    
+    end
+  
+    def create_file(filename, contents)
+      FileUtils.mkdir_p(SPEC_TMP_DIR) unless File.directory?(SPEC_TMP_DIR)
+    
+      in_current_dir do
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.open(filename, 'wb') { |f| f << contents }
+      end
+    end
+  
+    def in_current_dir(&block)
+      Dir.chdir(current_dir, &block)
+    end
+  
+    def current_dir
+      @current_dir ||= SPEC_TMP_DIR
+    end
+  end
+
+
+  module Spec
+    module Matchers
+      class IncludeAStringLike
+        def initialize(substring_or_regex)
+          case substring_or_regex
+          when String
+            @regex = Regexp.new(Regexp.escape(substring_or_regex))
+          when Regexp
+            @regex = substring_or_regex
+          else
+            raise ArgumentError, "don't know what to do with the #{substring_or_regex.class} you provided"
+          end
+        end
+
+        def matches?(list_of_strings)
+          @list_of_strings = list_of_strings
+          @list_of_strings.any? { |s| s =~ @regex }
+        end
+        def failure_message
+          "#{@list_of_strings.inspect} expected to include a string like #{@regex.inspect}"
+        end
+        def negative_failure_message
+          "#{@list_of_strings.inspect} expected to not include a string like #{@regex.inspect}, but did"
+        end
+      end
+
+      def include_a_string_like(substring_or_regex)
+        IncludeAStringLike.new(substring_or_regex)
+      end
+    end
   end
+
+  module Spork::TestIOStreams
+    def self.included(klass)
+      klass.send(:extend, ::Spork::TestIOStreams::ClassMethods)
+    end
+  
+    def stderr
+      self.class.stderr
+    end
+
+    def stdout
+      self.class.stdout
+    end
+  
+    module ClassMethods
+      def stderr
+        $test_stderr
+      end
   
-  config.after(:each) do
-    FileUtils.rm_rf(SPEC_TMP_DIR)
+      def stdout
+        $test_stdout
+      end
+    end
   end
 end

data/spec/spork/app_framework/rails_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+Spork::AppFramework[:Rails]
+
+describe Spork::AppFramework::Rails do
+  describe ".version" do
+    it "detects the current version of rails" do
+      create_file("config/environment.rb", "RAILS_GEM_VERSION = '2.1.0'")
+      in_current_dir do
+        Spork::AppFramework::Rails.new.version.should == "2.1.0"
+      end
+      
+      create_file("config/environment.rb", 'RAILS_GEM_VERSION = "2.1.0"')
+      in_current_dir do
+        Spork::AppFramework::Rails.new.version.should == "2.1.0"
+      end
+      
+      create_file("config/environment.rb", 'RAILS_GEM_VERSION = "> 2.1.0"')
+      in_current_dir do
+        Spork::AppFramework::Rails.new.version.should == "> 2.1.0"
+      end
+    end
+  end
+end

data/spec/spork/app_framework_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spork::AppFramework do
+  describe ".detect_framework" do
+    it "detects when rails is installed and available" do
+      create_file("config/environment.rb", "RAILS_GEM_VERSION = '2.1.0'")
+      in_current_dir do
+        Spork::AppFramework.detect_framework.name.should == "Rails"
+      end
+    end
+  
+    it "returns Unknown when no framework known detected" do
+      Spork::AppFramework.detect_framework.name.should == "Unknown"
+    end
+  end
+end

data/spec/spork/diagnoser_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+
+describe Spork::Diagnoser do
+  after(:each) do
+    Spork::Diagnoser.remove_hook!
+    Spork::Diagnoser.loaded_files.clear
+  end
+  
+  def run_simulation(directory, filename = nil, contents = nil, &block)
+    FileUtils.mkdir_p(directory)
+    Dir.chdir(directory) do
+      if filename
+        File.open(filename, 'wb') { |f| f << contents }
+        Spork::Diagnoser.install_hook!
+        require filename
+      end
+      yield if block_given?
+    end
+  end
+  
+  it "installs it's hook and tells you when files have been loaded" do
+    run_simulation(SPEC_TMP_DIR, 'my_awesome_library_include.rb', '1 + 5')
+    Spork::Diagnoser.loaded_files.keys.should include_a_string_like('my_awesome_library_include')
+    
+  end
+  
+  it 'excludes files outside of Dir.pwd' do
+    run_simulation(SPEC_TMP_DIR + '/project_root', '../external_dependency.rb', '1 + 5')
+    Spork::Diagnoser.loaded_files.keys.should_not include_a_string_like('external_dependency')
+    
+  end
+  
+  it "excludes files outside of Dir.pwd but in ruby's include path" do
+    directory = SPEC_TMP_DIR + '/project_root'
+    external_dependency_dir = SPEC_TMP_DIR + '/external_dependency'
+    $: << external_dependency_dir
+    FileUtils.mkdir_p(directory)
+    FileUtils.mkdir_p(external_dependency_dir)
+    Dir.chdir(directory) do
+      File.open(external_dependency_dir + '/the_most_awesome_external_dependency_ever.rb', 'wb') { |f| f << 'funtimes = true' }
+      Spork::Diagnoser.install_hook!
+      require 'the_most_awesome_external_dependency_ever'
+    end
+    
+    Spork::Diagnoser.loaded_files.keys.should_not include_a_string_like('the_most_awesome_external_dependency_ever')
+    $:.pop
+  end
+  
+  it "expands files to their fully their fully qualified path" do
+    directory = SPEC_TMP_DIR + '/project_root'
+    lib_directory = directory + '/lib'
+    $: << lib_directory
+    FileUtils.mkdir_p(lib_directory)
+    Dir.chdir(directory) do
+      File.open(lib_directory + "/the_most_awesome_lib_file_ever.rb", "wb") { |f| f << "funtimes = true" }
+      Spork::Diagnoser.install_hook!
+      require 'the_most_awesome_lib_file_ever'
+    end
+    
+    Spork::Diagnoser.loaded_files.keys.should include_a_string_like('lib/the_most_awesome_lib_file_ever')
+    $:.pop
+  end
+  
+  it "can tell the difference between a folder in the project path and a file in an external path" do
+    directory = SPEC_TMP_DIR + '/project_root'
+    external_dependency_dir = SPEC_TMP_DIR + '/external_dependency'
+    $: << external_dependency_dir
+    FileUtils.mkdir_p(directory)
+    FileUtils.mkdir_p(external_dependency_dir)
+    Dir.chdir(directory) do
+      FileUtils.mkdir_p(directory + '/a_popular_folder_name')
+      File.open(external_dependency_dir + '/a_popular_folder_name.rb', 'wb') { |f| f << 'funtimes = true' }
+      Spork::Diagnoser.install_hook!
+      require 'a_popular_folder_name'
+    end
+    
+    Spork::Diagnoser.loaded_files.keys.should_not include_a_string_like('a_popular_folder_name')
+    $:.pop
+  end
+  
+  it "outputs the results relative to the current directory" do
+    Spork::Diagnoser.loaded_files["/project_path/lib/file.rb"] = "/project_path/lib/parent_file.rb:35"
+    Dir.stub!(:pwd).and_return("/project_path")
+    out = StringIO.new
+    Spork::Diagnoser.output_results(out)
+    out.string.should =~ %r([^/]lib/file.rb)
+    out.string.should =~ %r([^/]lib/parent_file.rb)
+    out.string.should_not include("/project_path/")
+  end
+end

data/spec/spork/runner_spec.rb

@@ -11,7 +11,7 @@ describe Spork::Runner do
   
   it "shows an error message if no matching server was found" do
     Spork::Runner.new(["argle_bargle"], @out, @err).run.should == false
-    @out.string.should include(%("argle_bargle" didn't match a supported test framework))
+    @err.string.should include(%("argle_bargle" didn't match a supported test framework))
   end
   
   it "defaults to use rspec over cucumber" do
@@ -44,7 +44,7 @@ describe Spork::Runner do
     Spork::Server::RSpec.should_receive(:preload).and_return(true)
     Spork::Server::RSpec.should_receive(:run).and_return(true)
     Spork::Runner.new(['rspec'], @out, @err).run
-    @out.string.should include("Using RSpec")
+    @err.string.should include("Using RSpec")
   end
   
   it "outputs a list of supported servers, along with supported asterisk" do

data/spec/spork/server_spec.rb

@@ -1,7 +1,11 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
+
 class FakeServer < Spork::Server
   attr_accessor :wait_time
+  
+  include Spork::TestIOStreams
+  
   def self.helper_file
     SPEC_TMP_DIR + "/fake/test_helper.rb"
   end
@@ -10,14 +14,6 @@ class FakeServer < Spork::Server
     1000
   end
   
-  def self.puts(string)
-    $test_stdout.puts(string)
-  end
-  
-  def puts(string)
-    $test_stdout.puts(string)
-  end
-  
   def run_tests(argv, input, output)
     sleep(@wait_time || 0.5)
     true
@@ -58,8 +54,7 @@ describe Spork::Server do
   
   describe "a fake server" do
     def create_helper_file
-      FileUtils.mkdir_p(File.dirname(FakeServer.helper_file))
-      FileUtils.touch(FakeServer.helper_file)
+      create_file(FakeServer.helper_file, "# stub spec helper file")
     end
   
     before(:each) do
@@ -94,9 +89,9 @@ describe Spork::Server do
       create_helper_file
       FakeServer.bootstrap
     
-      $test_stdout.string.should include("Bootstrapping")
-      $test_stdout.string.should include("Edit")
-      $test_stdout.string.should include("favorite text editor")
+      $test_stderr.string.should include("Bootstrapping")
+      $test_stderr.string.should include("Edit")
+      $test_stderr.string.should include("favorite text editor")
     
       File.read(FakeServer.helper_file).should include(File.read(FakeServer::BOOTSTRAP_FILE))
     end

data/spec/spork_spec.rb

@@ -3,8 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 Spork.class_eval do
   def self.reset!
     @state = nil
-    @already_run = nil
-    @already_preforked = nil
+    @already_ran = nil
   end
 end
 
@@ -14,28 +13,28 @@ describe Spork do
   end
   
   def spec_helper_simulator
-    ran = []
+    @ran ||= []
     Spork.prefork do
-      ran << :prefork
+      @ran << :prefork
     end
     
     Spork.each_run do
-      ran << :each_run
+      @ran << :each_run
     end
-    ran
+    @ran
   end
   
   it "only runs the preload block when preforking" do
-    ran = []
-    Spork.preforking!
-    spec_helper_simulator.should == [:prefork]
+    Spork.exec_prefork { spec_helper_simulator }
+    @ran.should == [:prefork]
   end
   
   it "only runs the each_run block when running" do
-    Spork.preforking!
-    spec_helper_simulator
-    Spork.running!
-    spec_helper_simulator.should == [:each_run]
+    Spork.exec_prefork { spec_helper_simulator }
+    @ran.should == [:prefork]
+    
+    Spork.exec_each_run
+    @ran.should == [:prefork, :each_run]
   end
   
   it "runs both blocks when Spork not activated" do
@@ -43,8 +42,12 @@ describe Spork do
   end
   
   it "prevents blocks from being ran twice" do
-    spec_helper_simulator.should == [:prefork, :each_run]
-    spec_helper_simulator.should == []
+    Spork.exec_prefork { spec_helper_simulator }
+    Spork.exec_each_run
+    @ran.clear
+    Spork.exec_prefork { spec_helper_simulator }
+    Spork.exec_each_run
+    @ran.should == []
   end
   
   it "runs multiple prefork and each_run blocks at different locations" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timcharper-spork
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors: 
 - Tim Harper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-01 00:00:00 -07:00
+date: 2009-06-05 00:00:00 -07:00
 default_executable: spork
 dependencies: []
 
@@ -27,13 +27,29 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - assets/bootstrap.rb
+- features/diagnostic_mode.feature
+- features/rails_integration.feature
+- features/steps/rails_steps.rb
+- features/steps/sandbox_steps.rb
+- features/support/env.rb
 - lib/spork.rb
+- lib/spork/app_framework.rb
+- lib/spork/app_framework/rails.rb
+- lib/spork/app_framework/rails_stub_files/application.rb
+- lib/spork/app_framework/rails_stub_files/application_controller.rb
+- lib/spork/app_framework/rails_stub_files/application_helper.rb
+- lib/spork/app_framework/unknown.rb
+- lib/spork/custom_io_streams.rb
+- lib/spork/diagnoser.rb
 - lib/spork/forker.rb
 - lib/spork/runner.rb
 - lib/spork/server.rb
 - lib/spork/server/cucumber.rb
 - lib/spork/server/rspec.rb
 - spec/spec_helper.rb
+- spec/spork/app_framework/rails_spec.rb
+- spec/spork/app_framework_spec.rb
+- spec/spork/diagnoser_spec.rb
 - spec/spork/forker_spec.rb
 - spec/spork/runner_spec.rb
 - spec/spork/server/rspec_spec.rb
@@ -68,6 +84,9 @@ specification_version: 2
 summary: spork
 test_files: 
 - spec/spec_helper.rb
+- spec/spork/app_framework/rails_spec.rb
+- spec/spork/app_framework_spec.rb
+- spec/spork/diagnoser_spec.rb
 - spec/spork/forker_spec.rb
 - spec/spork/runner_spec.rb
 - spec/spork/server/rspec_spec.rb