milhouse-spork 0.7.5.1 → 0.7.5.2

data/features/support/env.rb

@@ -1,111 +1,111 @@
-require 'rubygems'
-require 'fileutils'
-require 'forwardable'
-require 'tempfile'
-require 'spec/expectations'
-require 'timeout'
-require 'spork'
-
-require(File.dirname(__FILE__) + '/background_job.rb')
-
-class SporkWorld
-  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/spork')
-  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-  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 last_stderr
-    return @last_stderr if @last_stderr
-    if @background_job
-      @last_stderr = @background_job.stderr.read
-    end
-  end
-
-
-  def last_stdout
-    return @last_stdout if @last_stdout
-    if @background_job
-      @last_stdout = @background_job.stdout.read
-    end
-  end
-
-  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 localized_command(command, args)
-    case command
-    when 'spork'
-      command = SporkWorld::BINARY
-    when 'cucumber'
-      command = Cucumber::BINARY
-    else
-      command = %x{which #{command}}.chomp
-    end
-    "#{SporkWorld::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{command} #{args}"
-  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)
-    in_current_dir do
-      @background_job = BackgroundJob.run(command)
-    end
-    @background_jobs << @background_job
-    @background_job
-  end
-
-  def terminate_background_jobs
-    if @background_jobs
-      @background_jobs.each do |background_job|
-        background_job.kill
-      end
-    end
-    @background_jobs.clear
-    @background_job = nil
-  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
+require 'rubygems'
+require 'fileutils'
+require 'forwardable'
+require 'tempfile'
+require 'spec/expectations'
+require 'timeout'
+require 'spork'
+
+require(File.dirname(__FILE__) + '/background_job.rb')
+
+class SporkWorld
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/spork')
+  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  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 last_stderr
+    return @last_stderr if @last_stderr
+    if @background_job
+      @last_stderr = @background_job.stderr.read
+    end
+  end
+
+
+  def last_stdout
+    return @last_stdout if @last_stdout
+    if @background_job
+      @last_stdout = @background_job.stdout.read
+    end
+  end
+
+  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 localized_command(command, args)
+    case command
+    when 'spork'
+      command = SporkWorld::BINARY
+    when 'cucumber'
+      command = Cucumber::BINARY
+    else
+      command = %x{which #{command}}.chomp
+    end
+    "#{SporkWorld::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{command} #{args}"
+  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)
+    in_current_dir do
+      @background_job = BackgroundJob.run(command)
+    end
+    @background_jobs << @background_job
+    @background_job
+  end
+
+  def terminate_background_jobs
+    if @background_jobs
+      @background_jobs.each do |background_job|
+        background_job.kill
+      end
+    end
+    @background_jobs.clear
+    @background_job = nil
+  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/features/unknown_app_framework.feature

@@ -1,42 +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"
+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/geminstaller.yml

@@ -1,9 +1,9 @@
-defaults:
-  install_options: "--no-ri --no-rdoc"
-gems:
-- { name: 'sqlite3-ruby',            version: '>= 1.2.5' }
-- { name: 'cucumber',                version: '>= 0.4.0' }
-- { name: 'rspec',                   version: '>= 1.2.9' }
-- { name: 'rspec-rails',             version: '>= 1.2.9' }
-- { name: 'rails',                   version: '>= 2.3' }
-- { name: 'ruby-debug',              version: '>= 0.10.3' }
+defaults:
+  install_options: "--no-ri --no-rdoc"
+gems:
+- { name: 'sqlite3-ruby',            version: '>= 1.2.5' }
+- { name: 'cucumber',                version: '>= 0.4.0' }
+- { name: 'rspec',                   version: '>= 1.2.9' }
+- { name: 'rspec-rails',             version: '>= 1.2.9' }
+- { name: 'rails',                   version: '>= 2.3' }
+- { name: 'ruby-debug',              version: '>= 0.10.3' }

data/lib/spork/app_framework/rails.rb

@@ -1,158 +1,158 @@
-class Spork::AppFramework::Rails < Spork::AppFramework
-  
-  # TODO - subclass this out to handle different versions of rails
-  # Also... this is the nastiest duck punch ever.  Clean this up.
-  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
-        
-        def self.run_with_spork(*args, &block) # it's all fun and games until someone gets an eye poked out
-          if ENV['RAILS_ENV']
-            Object.send(:remove_const, :RAILS_ENV)
-            Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
-          end
-          run_without_spork(*args, &block)
-        end
-        
-        class << self
-          unless method_defined?(:run_without_spork)
-            alias :run_without_spork :run
-            alias :run :run_with_spork
-          end
-        end
-      end
-    end
-    
-    def load_environment_with_spork
-      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
-      delay_eager_view_loading
-    end
-    
-    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) if ActionController::Dispatcher.respond_to?(:define_dispatcher_callbacks)
-      end
-    end
-    
-    def delay_app_preload
-      if ::Rails::Initializer.instance_methods.include?('load_application_classes')
-        Spork.trap_method(::Rails::Initializer, :load_application_classes)
-      end
-    end
-    
-    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 = (::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 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
-    
-    def delay_route_loading
-      if ::Rails::Initializer.instance_methods.include?('initialize_routing')
-        Spork.trap_method(::Rails::Initializer, :initialize_routing)
-      end
-    end
-    
-    def delay_eager_view_loading
-      # So, in testing mode it seems it would be optimal to not eager load 
-      # views (as your may only run a test that uses one or two views).
-      # However, I decided to delay eager loading rather than force it to 
-      # disable because you may wish to eager load your views (I.E. you're 
-      # testing concurrency)
-      
-      # Rails 2.3.x +
-      if defined?(::ActionView::Template::EagerPath)
-        Spork.trap_method(::ActionView::Template::EagerPath, :load!)
-      end
-      # Rails 2.2.x
-      if defined?(::ActionView::PathSet::Path)
-        Spork.trap_method(::ActionView::PathSet::Path, :load)
-      end
-      # Rails 2.0.5 - 2.1.x don't appear to eager cache views.
-    end
-  end
-  
-  def preload(&block)
-    STDERR.puts "Preloading Rails environment"
-    STDERR.flush
-    ENV["RAILS_ENV"] ||= 'test'
-    preload_rails
-    yield
-  end
-  
-  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
-  
-  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 preload_rails
-    Object.const_set(:RAILS_GEM_VERSION, version) if version
-    require boot_file
-    ::Rails::Initializer.send(:include, Spork::AppFramework::Rails::NinjaPatcher)
-  end
-  
+class Spork::AppFramework::Rails < Spork::AppFramework
+  
+  # TODO - subclass this out to handle different versions of rails
+  # Also... this is the nastiest duck punch ever.  Clean this up.
+  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
+        
+        def self.run_with_spork(*args, &block) # it's all fun and games until someone gets an eye poked out
+          if ENV['RAILS_ENV']
+            Object.send(:remove_const, :RAILS_ENV)
+            Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
+          end
+          run_without_spork(*args, &block)
+        end
+        
+        class << self
+          unless method_defined?(:run_without_spork)
+            alias :run_without_spork :run
+            alias :run :run_with_spork
+          end
+        end
+      end
+    end
+    
+    def load_environment_with_spork
+      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
+      delay_eager_view_loading
+    end
+    
+    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) if ActionController::Dispatcher.respond_to?(:define_dispatcher_callbacks)
+      end
+    end
+    
+    def delay_app_preload
+      if ::Rails::Initializer.instance_methods.include?('load_application_classes')
+        Spork.trap_method(::Rails::Initializer, :load_application_classes)
+      end
+    end
+    
+    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 = (::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 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
+    
+    def delay_route_loading
+      if ::Rails::Initializer.instance_methods.include?('initialize_routing')
+        Spork.trap_method(::Rails::Initializer, :initialize_routing)
+      end
+    end
+    
+    def delay_eager_view_loading
+      # So, in testing mode it seems it would be optimal to not eager load 
+      # views (as your may only run a test that uses one or two views).
+      # However, I decided to delay eager loading rather than force it to 
+      # disable because you may wish to eager load your views (I.E. you're 
+      # testing concurrency)
+      
+      # Rails 2.3.x +
+      if defined?(::ActionView::Template::EagerPath)
+        Spork.trap_method(::ActionView::Template::EagerPath, :load!)
+      end
+      # Rails 2.2.x
+      if defined?(::ActionView::PathSet::Path)
+        Spork.trap_method(::ActionView::PathSet::Path, :load)
+      end
+      # Rails 2.0.5 - 2.1.x don't appear to eager cache views.
+    end
+  end
+  
+  def preload(&block)
+    STDERR.puts "Preloading Rails environment"
+    STDERR.flush
+    ENV["RAILS_ENV"] ||= 'test'
+    preload_rails
+    yield
+  end
+  
+  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
+  
+  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 preload_rails
+    Object.const_set(:RAILS_GEM_VERSION, version) if version
+    require boot_file
+    ::Rails::Initializer.send(:include, Spork::AppFramework::Rails::NinjaPatcher)
+  end
+  
 end

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

@@ -1 +1 @@
-load(File.dirname(__FILE__) + "/application_controller.rb")
+load(File.dirname(__FILE__) + "/application_controller.rb")