timcharper-spork 0.5.0 → 0.5.5

data/README.rdoc

@@ -8,11 +8,9 @@ Spork is Tim Harper's implementation of a Drb spec server (similar to the script
 
 Because Spork uses Kernel.fork, it only works on POSIX systems.  This means Windows users are not invited to this party.  Sorry :(
 
-Spork is still experimental, but is performing solid for us.
-
 == INSTALL:
 
-  [sudo] gem install timcharper-spork --source http://gems.github.com/
+  [sudo] gem install spork
 
 alternatively:
 
@@ -35,23 +33,54 @@ Finally, run spork.  A spec DRb server will be running!
 
   spork
 
-To get the TextMate RSpec bundle to use spork, go to config->advanced->shell variables, and add TM_RSPEC_OPTS=--drb.
+== Diagnostic mode
+
+Initially, you may find that a few files don't reload automatically.  This is because they are being loaded during Spork startup.  To identify which project files are being pre-loaded, and why, run:
+
+  spork --diagnose
+  (or spork -d, for short)
+
+It will output a lot of stuff.  At the top you'll find a summary of all project files loaded.  Down below, the stack trace for each file (how it got loaded).  Spork hooks into Rails and does some magic (TM) to prevent ApplicationController observers, etc from pre-loading.  Similar hooks for other ruby frameworks may come as support demands.
+
+== Running specs over Spork
+
+=== RSpec
+
+To get the TextMate RSpec bundle to use spork, go to config->advanced->shell variables, and add:
+
+  TM_RSPEC_OPTS=--drb.
 
-To run from the command line, use spec --drb spec/lib/my_spec.rb
+To run from the command line, use:
 
-Or, you could add --drb to your spec.opts file.
+  spec --drb spec/lib/my_spec.rb
+
+Or, you could add the following flag to your +spec.opts+ file.
+
+  --drb
+
+=== Cucumber
+
+Cucumber --drb support for spork is not official yet (but it works).  It's the hottest sauce boiling on the world wide web right now.  If you can't wait to try it, head on over to Cucumber core-team member Ben Mabey's drb branch and build your own cucumber gem:
+
+  http://github.com/bmabey/cucumber/tree/drb_server
+
+Use this as a guideline when "Sporking" your features/support/env.rb file
+
+  http://gist.github.com/123370
 
 == Some potential issues and ways to overcome them:
 
-=== ActiveRecord reports "connection has gone away" for the first few specs
+=== Database connections don't work inside of Spork
 
-Not sure why this happens, but if you simply add a line to re-establish your database connection on each line as follows, the problem goes away:
+If you're using ActiveRecord and Rails, Spork will automatically reconnect to the database.  However, if you're not using ActiveRecord, or if you're doing some tricky stuff with connections, you'll have to make sure your connections get re-established on each run.  In your spec/spec_helper.rb file:
 
   Spork.each_run do
-    ActiveRecord::Base.establish_connection # make sure that the db connection is ready.
+    # Do your connection re-establishing here
   end
 
-=== Couldn't find formatter class Spec::Runner::Formatter::TextMateFormatter Make sure the --require option is specified *before* --format
+=== Couldn't find formatter class Spec::Runner::Formatter::TextMateFormatter
+
+  Make sure the --require option is specified *before* --format
 
 On one of our projects, many of us using TextMate with spork, only one developer got this error message while the rest of us ran just fine.  I don't know exactly why it happened, but requiring the textmate formatter in the prefork block made it go away, like this:
 
@@ -65,7 +94,7 @@ On one of our projects, many of us using TextMate with spork, only one developer
 
 == Kudos to
 
-* Ben Mabey - help with documentation, testing, suggestions, patches, collaborated with Cucumber support.
+* Ben Mabey - help with documentation, testing, suggestions, patches, and bringing Cucumber support.
 * David Chelimsky - for the fine RSpec testing framework, and the original rspec-rails spec_server implementation, which Spork has built upon.
 * Lead Media Partners - just for being an awesome place to work.
 

data/assets/bootstrap.rb

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'spork'
 
 Spork.prefork do
-  # Loading more in this block will cause your specs to run faster. However, 
+  # Loading more in this block will cause your tests to run faster. However, 
   # if you change any configuration or code from libraries loaded here, you'll
   # need to restart spork for it take effect.
   

data/features/cucumber_rails_integration.feature

@@ -0,0 +1,103 @@
+Feature: Cucumber integration with rails
+  As a developer using cucumber and rails
+  I want to use Spork with Cucumber
+  In order to eliminate the startup cost of my application each time I run them
+  
+  Background: Sporked env.rb
+    Given I am in a fresh rails project named "test_rails_project"
+    And the application has a model, observer, route, and application helper
+    And a file named "features/support/env.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+
+      Spork.prefork do
+        # Loading more in this block will cause your tests to run faster. However, 
+        # if you change any configuration or code from libraries loaded here, you'll
+        # need to restart spork for it take effect.
+        
+        # Sets up the Rails environment for Cucumber
+        ENV['RAILS_ENV'] = "cucumber"
+        require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+
+        require 'webrat'
+
+        Webrat.configure do |config|
+          config.mode = :rails
+        end
+
+        require 'webrat/core/matchers'
+        require 'cucumber'
+        require 'cucumber/formatter/unicode' # Comment out this line if you don't want Cucumber Unicode support
+        require 'spec/rails'
+        require 'cucumber/rails/rspec'
+        
+        #### this is for this test only #######
+        $loaded_stuff << 'prefork block' ######
+        #######################################
+      end
+
+      Spork.each_run do
+        # This code will be run each time you run your specs.
+        require 'cucumber/rails/world'
+        Cucumber::Rails.use_transactional_fixtures
+        Cucumber::Rails.bypass_rescue # Comment out this line if you want Rails own error handling
+                                      # (e.g. rescue_action_in_public / rescue_responses / rescue_from)
+        
+        #### this is for this test only #######
+        $loaded_stuff << 'each_run block' #####
+        #######################################
+      end
+      """
+    And a file named "features/cucumber_rails.feature" with:
+      """
+      Feature: cucumber rails
+        Scenario: did it work
+          Then it should work
+      """
+    And a file named "features/support/cucumber_rails_helper.rb" with:
+      """
+      $loaded_stuff << 'features/support/cucumber_rails_helper.rb'
+      """
+    And a file named "config/environments/cucumber.rb" with:
+      """
+      # your cucumber env here
+      """
+    And a file named "config/database.yml" with:
+      """
+      cucumber:
+        adapter: sqlite3
+        database: db/cucumber.sqlite3
+        timeout: 5000
+      """
+    And a file named "features/step_definitions/cucumber_rails_steps.rb" with:
+      """
+      Then "it should work" do
+        Spork.state.should == :using_spork
+        RAILS_ENV.should == 'cucumber'
+        $loaded_stuff.should include('ActiveRecord::Base.establish_connection')
+        $loaded_stuff.should include('User')
+        $loaded_stuff.should include('UserObserver')
+        $loaded_stuff.should include('ApplicationHelper')
+        $loaded_stuff.should include('config/routes.rb')
+        $loaded_stuff.should include('features/support/cucumber_rails_helper.rb')
+        $loaded_stuff.should include('each_run block')
+        $loaded_stuff.should include('prefork block')
+        puts "It worked!"
+      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"
+      Then the output should not contain "config/routes.rb"
+      Then the output should not contain "features/step_definitions/cucumber_rails_steps.rb"
+      Then the output should not contain "features/support/cucumber_rails_helper.rb"
+      
+    Scenario: Running spork with a rails app and observers
+      When I fire up a spork instance with "spork cucumber"
+      And I run cucumber --drb features/cucumber_rails.feature
+      Then the output should contain "It worked!"

data/features/rails_delayed_loading_workarounds.feature

@@ -0,0 +1,71 @@
+Feature: Rails Delayed Work arounds
+  To allow a rails developer to update as many parts of his application as possible without needing to restart Spork
+  Spork automatically tells rails to delay loading certain parts of the application until after the fork occurs
+  Providing work arounds
+
+  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'
+
+      Spork.prefork do
+        require File.dirname(__FILE__) + '/../config/environment.rb'
+        require 'spec'
+        require 'spec/rails'
+      end
+
+      Spork.each_run do
+      end
+      """
+    And the application has a model, observer, route, and application helper
+  Scenario: within a view, calling helper methods from an included module in ApplicationHelper
+    Given a file named "app/helpers/application_helper.rb" with:
+      """
+      module ApplicationHelper
+        include Reverseatron
+      end
+      """
+    Given a file named "lib/reverseatron.rb" with:
+      """
+      module Reverseatron
+        def reverse_text(txt)
+          txt.reverse
+        end
+      end
+      """
+    Given a file named "app/controllers/users_controller.rb" with:
+      """
+      class UsersController < ApplicationController
+        $loaded_stuff << 'UsersController'
+        def index
+          @users = []
+        end
+      end
+      """
+    Given a file named "app/controllers/users_helper.rb" with:
+      """
+      module UsersHelper
+      end
+      """
+    Given a file named "app/views/users/index.html.erb" with:
+      """
+      <%= reverse_text('listing users'.reverse) %>
+      """
+    Given a file named "spec/controllers/users_controller_spec.rb" with:
+      """
+      describe UsersController do
+        integrate_views
+        it "renders a page, using a method inherited from ApplicationController" do
+          get :index
+          response.body.should include('listing users')
+          puts "Controller stack is functioning"
+        end
+      end
+      """
+    When I fire up a spork instance with "spork rspec"
+    And I run spec --drb spec/controllers/users_controller_spec.rb
+    Then the output should contain "Controller stack is functioning"
+  

data/features/rspec_rails_integration.feature

@@ -0,0 +1,64 @@
+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'
+
+      Spork.prefork do
+        # Loading more in this block will cause your specs to run faster. However, 
+        # if you change any configuration or code from libraries loaded here, you'll
+        # need to restart spork for it take effect.
+        require File.dirname(__FILE__) + '/../config/environment.rb'
+        require 'spec'
+        require 'spec/rails'
+        
+        #### this is for this test only #######
+        $loaded_stuff << 'prefork block' ######
+        #######################################
+      end
+
+      Spork.each_run do
+        # This code will be run each time you run your specs.
+        
+        #### this is for this test only #######
+        $loaded_stuff << 'each_run block' #####
+        #######################################
+      end
+      """
+    And the application has a model, observer, route, and application helper
+  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"
+    Then the output should not contain "config/routes.rb"
+  
+  Scenario: Running spork with a rails app and observers
+    Given a file named "spec/did_it_work_spec.rb" with:
+    """
+    describe "Did it work?" do
+      it "checks to see if all worked" do
+        Spork.state.should == :using_spork
+        $loaded_stuff.should include('ActiveRecord::Base.establish_connection')
+        $loaded_stuff.should include('User')
+        $loaded_stuff.should include('UserObserver')
+        $loaded_stuff.should include('ApplicationHelper')
+        $loaded_stuff.should include('config/routes.rb')
+        $loaded_stuff.should include('each_run block')
+        $loaded_stuff.should include('prefork block')
+        puts "Specs successfully run within spork, and all initialization files were loaded"
+      end
+    end
+    """
+    When I fire up a spork instance with "spork rspec"
+    And I run spec --drb spec/did_it_work_spec.rb 
+    Then the output should contain "Specs successfully run within spork, and all initialization files were loaded"

data/features/steps/rails_steps.rb

@@ -1,5 +1,53 @@
 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}")
+  version_argument = ENV['RAILS_VERSION'] ? "_#{ENV['RAILS_VERSION']}_" : nil
+  # run("#{SporkWorld::RUBY_BINARY} #{%x{which rails}.chomp} #{folder_name}")
+  run([SporkWorld::RUBY_BINARY, %x{which rails}.chomp, version_argument, folder_name].compact * " ")
   @current_dir = File.join(File.join(SporkWorld::SANDBOX_DIR, folder_name))
 end
+
+
+Given "the application has a model, observer, route, and application helper" do
+  Given 'a file named "app/models/user.rb" with:',
+    """
+    class User < ActiveRecord::Base
+      $loaded_stuff << 'User'
+    end
+    """
+  Given 'a file named "app/models/user_observer.rb" with:',
+    """
+    class UserObserver < ActiveRecord::Observer
+      $loaded_stuff << 'UserObserver'
+    end
+    """
+  Given 'a file named "app/helpers/application_helper.rb" with:',
+    """
+    module ApplicationHelper
+      $loaded_stuff << 'ApplicationHelper'
+    end
+    """
+  Given 'the following code appears in "config/environment.rb" after /Rails::Initializer.run/:',
+    """
+      config.active_record.observers = :user_observer
+    """
+  Given 'the following code appears in "config/routes.rb" after /^end/:',
+    """
+      $loaded_stuff << 'config/routes.rb'
+    """
+  Given 'a file named "config/initializers/initialize_loaded_stuff.rb" with:',
+    """
+    $loaded_stuff ||= []
+    """
+  Given 'a file named "config/initializers/log_establish_connection_calls.rb" with:',
+    """
+    class ActiveRecord::Base
+      class << self
+        def establish_connection_with_load_logging(*args)
+          establish_connection_without_load_logging(*args)
+          $loaded_stuff << 'ActiveRecord::Base.establish_connection'
+        end
+        alias_method_chain :establish_connection, :load_logging
+      end
+    end
+    """
+end

data/features/steps/sandbox_steps.rb

@@ -12,7 +12,24 @@ 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|
+# the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
+Given /^the following code appears in "([^\"]*)" after \/([^\\\/]*)\/:$/ do |file_name, regex, content|
+  # require 'ruby-debug'; Debugger.start; Debugger.start_control; debugger
+  
+  regex = Regexp.new(regex)
+  in_current_dir do
+    content_lines = File.read(file_name).split("\n")
+    0.upto(content_lines.length - 1) do |line_index|
+      if regex.match(content_lines[line_index])
+        content_lines.insert(line_index + 1, content)
+        break
+      end
+    end
+    File.open(file_name, 'wb') { |f| f << (content_lines * "\n") }
+  end
+end
+
+When /^I run (spork|spec|cucumber)($| .*$)/ do |command, spork_opts|
   if command == 'spork'
     command = SporkWorld::BINARY
   else
@@ -39,22 +56,26 @@ When /^I fire up a spork instance with "spork(.*)"$/ do |spork_opts|
   end
 end
 
-Then /^the output should contain$/ do |text|
-  last_stdout.should include(text)
+Then /^the (error output|output) should contain$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should include(text)
+end
+
+Then /^the (error output|output) should contain "(.+)"$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should include(text)
 end
 
-Then /^the output should contain "(.+)"$/ do |text|
-  last_stdout.should include(text)
+Then /^the (error output|output) should match \/(.+)\/$/ do |which, regex|
+  (which == "error output" ? last_stderr : last_stdout).should match(Regexp.new(regex))
 end
 
-Then /^the output should not contain$/ do |text|
-  last_stdout.should_not include(text)
+Then /^the (error output|output) should not contain$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
 end
 
-Then /^the output should not contain "(.+)"$/ do |text|
-  last_stdout.should_not include(text)
+Then /^the (error output|output) should not contain "(.+)"$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
 end
 
-Then /^the output should be$/ do |text|
-  last_stdout.should == text
+Then /^the (error output|output) should be$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should == text
 end

data/features/support/env.rb

@@ -53,7 +53,6 @@ class SporkWorld
     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)

data/features/unknown_app_framework.feature

@@ -0,0 +1,42 @@
+Feature: Unknown app frameworks
+  To increase to usefulness of Spork 
+  Spork will work with unknown (or no) application frameworks
+
+  Scenario: Unsporked spec_helper
+  
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spec'
+      """
+    When I run spork
+    Then the error output should contain "Using RSpec"
+    Then the error output should match /You must bootstrap .+spec\/spec_helper\.rb to continue/
+  
+  Scenario: Sporked spec_helper
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+      
+      Spork.prefork do
+        require 'spec'
+      end
+      
+      Spork.each_run do
+        $each_run
+      end
+      """
+    And a file named "spec/did_it_work_spec.rb" with:
+      """
+      describe "Did it work?" do
+        it "checks to see if all worked" do
+          Spork.state.should == :using_spork
+          puts "Specs successfully run within spork"
+        end
+      end
+      """
+    When I fire up a spork instance with "spork rspec"
+    And I run spec --drb spec/did_it_work_spec.rb 
+    Then the output should contain "Specs successfully run within spork"
+  

data/lib/spork/app_framework/rails.rb

@@ -1,68 +1,82 @@
 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
+  module NinjaPatcher
+    def self.included(klass)
+      klass.class_eval do
+        unless method_defined?(:load_environment_without_spork)
+          alias :load_environment_without_spork :load_environment
+          alias :load_environment :load_environment_with_spork
         end
       end
     end
     
-    def self.install_specific_hooks
+    def load_environment_with_spork
+      reset_rails_env
+      result = load_environment_without_spork
+      install_hooks
+      result
+    end
+    
+    def install_hooks
       auto_reestablish_db_connection
       delay_observer_loading
       delay_app_preload
       delay_application_controller_loading
+      delay_route_loading
     end
     
-    def self.delay_observer_loading
-      if Object.const_defined?(:ActiveRecord)
-        Spork.trap_method(::ActiveRecord::Observing::ClassMethods, :instantiate_observers)
+    def reset_rails_env
+      return unless ENV['RAILS_ENV']
+      Object.send(:remove_const, :RAILS_ENV)
+      Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
+    end
+    
+    def delay_observer_loading
+      if ::Rails::Initializer.instance_methods.include?('load_observers')
+        Spork.trap_method(::Rails::Initializer, :load_observers)
       end
       if Object.const_defined?(:ActionController)
         require "action_controller/dispatcher.rb"
-        Spork.trap_class_method(::ActionController::Dispatcher, :define_dispatcher_callbacks)
+        Spork.trap_class_method(::ActionController::Dispatcher, :define_dispatcher_callbacks) if ActionController::Dispatcher.respond_to?(:define_dispatcher_callbacks)
       end
     end
     
-    def self.delay_app_preload
+    def 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
+    def 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 = (::ActiveSupport.const_defined?(:Dependencies) ? ::ActiveSupport::Dependencies : ::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)
+          # update the rails magic to refresh the module
+          ApplicationController.send(:helper, ApplicationHelper)
         end
       end
     end
     
-    def self.auto_reestablish_db_connection
+    def auto_reestablish_db_connection
       if Object.const_defined?(:ActiveRecord)
         Spork.each_run do
+          # rails lib/test_help.rb is very aggressive about overriding RAILS_ENV and will switch it back to test after the cucumber env was loaded
+          reset_rails_env
           ActiveRecord::Base.establish_connection
         end
       end
     end
-  end
-  
-  def bootstrap_required?
-    false
+    
+    def delay_route_loading
+      if ::Rails::Initializer.instance_methods.include?('initialize_routing')
+        Spork.trap_method(::Rails::Initializer, :initialize_routing)
+      end
+    end
   end
   
   def preload(&block)
@@ -70,14 +84,15 @@ class Spork::AppFramework::Rails < Spork::AppFramework
     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)
+  def entry_point
+    @entry_point ||= File.expand_path("config/environment.rb", Dir.pwd)
   end
   
+  alias :environment_file :entry_point
+  
   def boot_file
     @boot_file ||= File.join(File.dirname(environment_file), 'boot')
   end
@@ -100,14 +115,10 @@ class Spork::AppFramework::Rails < Spork::AppFramework
     )
   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
+    ::Rails::Initializer.send(:include, Spork::AppFramework::Rails::NinjaPatcher)
   end
   
 end

data/lib/spork/app_framework/unknown.rb

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

data/lib/spork/app_framework.rb

@@ -33,14 +33,18 @@ class Spork::AppFramework
   end
   
   def bootstrap_required?
-    raise NotImplemented
+    entry_point.nil?
+  end
+  
+  def entry_point
+    nil
   end
   
   def preload(&block)
     yield
   end
   
-  def name
+  def short_name
     self.class.short_name
   end
 end

data/lib/spork/diagnoser.rb

@@ -4,8 +4,9 @@ class Spork::Diagnoser
       @loaded_files ||= {}
     end
     
-    def install_hook!(dir = Dir.pwd)
+    def install_hook!(entry_file = nil, dir = Dir.pwd)
       @dir = File.expand_path(Dir.pwd, dir)
+      @entry_file = entry_file
       
       Kernel.class_eval do
         alias :require_without_diagnoser :require
@@ -26,21 +27,7 @@ class Spork::Diagnoser
     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)
+      loaded_files[filename] = filter_callstack(caller) if subdirectory?(filename)
     end
     
     def remove_hook!
@@ -68,5 +55,29 @@ class Spork::Diagnoser
         stdout.puts loaded_files[file].map(&minimify)
       end
     end
+    
+    private
+      def filter_callstack(callstack, entry_file = @entry_file)
+        callstack.pop until callstack.empty? || callstack.last.include?(@entry_file) if @entry_file
+        callstack.map do |line|
+          next if line.include?('lib/spork/diagnoser.rb')
+          line.gsub!('require_without_diagnoser', 'require')
+          line
+        end.compact
+      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
   end
 end

data/lib/spork/runner.rb

@@ -85,7 +85,7 @@ Are you running me from a project directory?
       when options[:diagnose]
         require 'spork/diagnoser'
         
-        Spork::Diagnoser.install_hook!
+        Spork::Diagnoser.install_hook!(server.entry_point)
         server.preload
         Spork::Diagnoser.output_results(@output)
         return true

data/lib/spork/server.rb

@@ -94,7 +94,7 @@ class Spork::Server
   end
   
   def run(argv, stderr, stdout)
-    return false if running?
+    abort if running?
     
     @child = ::Spork::Forker.new do
       $stdout, $stderr = stdout, stderr
@@ -113,6 +113,10 @@ class Spork::Server
       @framework ||= Spork::AppFramework.detect_framework
     end
     
+    def self.entry_point
+      bootstrapped? ? helper_file : framework.entry_point
+    end
+
     def self.preload
       Spork.exec_prefork do
         unless bootstrapped?
@@ -123,6 +127,8 @@ class Spork::Server
             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
+          else
+            load(framework.entry_point)
           end
         end
       

data/lib/spork.rb

@@ -51,7 +51,7 @@ module Spork
     def expanded_caller(caller_line)
       file, line = caller_line.split(":")
       line.gsub(/:.+/, '')
-      File.expand_path(Dir.pwd, file) + ":" + line
+      File.expand_path(file, Dir.pwd) + ":" + line
     end
     
     def trap_method(klass, method_name)

data/spec/spec_helper.rb

@@ -18,6 +18,7 @@ unless $spec_helper_loaded
     config.before(:each) do
       $test_stdout = StringIO.new
       $test_stderr = StringIO.new
+      @current_dir = nil
     end
   
     config.after(:each) do
@@ -41,6 +42,10 @@ unless $spec_helper_loaded
     def current_dir
       @current_dir ||= SPEC_TMP_DIR
     end
+    
+    def change_current_dir(sub_path)
+      @current_dir = File.expand_path(sub_path, SPEC_TMP_DIR)
+    end
   end
 
 

data/spec/spork/app_framework/unknown_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+Spork::AppFramework[:Unknown]
+
+describe Spork::AppFramework::Unknown do
+  it "requires bootstrapping" do
+    Spork::AppFramework::Unknown.new.bootstrap_required?.should == true
+  end
+  
+  it "has no known entry point" do
+    Spork::AppFramework::Unknown.new.entry_point.should be_nil
+  end
+end
+

data/spec/spork/app_framework_spec.rb

@@ -5,12 +5,12 @@ describe Spork::AppFramework 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"
+        Spork::AppFramework.detect_framework.short_name.should == "Rails"
       end
     end
   
     it "returns Unknown when no framework known detected" do
-      Spork::AppFramework.detect_framework.name.should == "Unknown"
+      Spork::AppFramework.detect_framework.short_name.should == "Unknown"
     end
   end
 end

data/spec/spork/diagnoser_spec.rb

@@ -22,13 +22,11 @@ describe Spork::Diagnoser do
   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
@@ -79,13 +77,29 @@ describe Spork::Diagnoser do
     $:.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/")
+  it "filters backtrace beyond the last line matching the entry point" do
+    Spork::Diagnoser.install_hook!("test_filter/environment.rb")
+    create_file("test_filter/environment.rb", "require 'test_filter/app.rb'")
+    create_file("test_filter/app.rb", "require 'test_filter/my_model.rb'")
+    create_file("test_filter/my_model.rb", "'my model here'")
+    in_current_dir do
+      require 'test_filter/environment.rb'
+    end
+    f = Spork::Diagnoser.loaded_files
+    f[f.keys.grep(/app.rb/).first].last.should include('test_filter/environment.rb')
+    f[f.keys.grep(/my_model.rb/).first].last.should include('test_filter/environment.rb')
+    f[f.keys.grep(/environment.rb/).first].should == []
+  end
+  
+  describe ".output_results" do
+    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
 end

data/spec/spork_spec.rb

@@ -55,4 +55,8 @@ describe Spork do
     Spork.each_run { }
     spec_helper_simulator.should == [:prefork, :each_run]
   end
+  
+  it "expands a caller line, preserving the line number" do
+    Spork.expanded_caller("/boo/../yah.rb:31").should == "/yah.rb:31"
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timcharper-spork
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.5
 platform: ruby
 authors: 
 - Tim Harper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-05 00:00:00 -07:00
+date: 2009-06-10 00:00:00 -07:00
 default_executable: spork
 dependencies: []
 
@@ -27,11 +27,14 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - assets/bootstrap.rb
+- features/cucumber_rails_integration.feature
 - features/diagnostic_mode.feature
-- features/rails_integration.feature
+- features/rails_delayed_loading_workarounds.feature
+- features/rspec_rails_integration.feature
 - features/steps/rails_steps.rb
 - features/steps/sandbox_steps.rb
 - features/support/env.rb
+- features/unknown_app_framework.feature
 - lib/spork.rb
 - lib/spork/app_framework.rb
 - lib/spork/app_framework/rails.rb
@@ -48,6 +51,7 @@ files:
 - lib/spork/server/rspec.rb
 - spec/spec_helper.rb
 - spec/spork/app_framework/rails_spec.rb
+- spec/spork/app_framework/unknown_spec.rb
 - spec/spork/app_framework_spec.rb
 - spec/spork/diagnoser_spec.rb
 - spec/spork/forker_spec.rb
@@ -85,6 +89,7 @@ summary: spork
 test_files: 
 - spec/spec_helper.rb
 - spec/spork/app_framework/rails_spec.rb
+- spec/spork/app_framework/unknown_spec.rb
 - spec/spork/app_framework_spec.rb
 - spec/spork/diagnoser_spec.rb
 - spec/spork/forker_spec.rb

data/features/rails_integration.feature

@@ -1,77 +0,0 @@
-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"