invo-sporknife 0.1.0.1 → 0.1.0.2

data/features/steps/sandbox_steps.rb

@@ -17,7 +17,7 @@ When /^the contents of "([^\"]*)" are changed to:$/ do |file_name, file_content|
 end
 
 # the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
-Given /^the following code appears in "([^\"]*)" after \/([^\/]*)\/:$/ do |file_name, regex, content|
+Given /^the following code appears in "([^\"]*)" after \/([^\\\/]*)\/:$/ do |file_name, regex, content|
   regex = Regexp.new(regex)
   in_current_dir do
     content_lines = File.read(file_name).split("\n")
@@ -31,12 +31,12 @@ Given /^the following code appears in "([^\"]*)" after \/([^\/]*)\/:$/ do |file_
   end
 end
 
-When /^I run (spork|rspec|cucumber)(| .*)$/ do |command, args|
-  run("#{command} #{args}")
+When /^I run (spork|spec|cucumber)(| .*)$/ do |command, args|
+  run(localized_command(command, args))
 end
 
-When /^I run this in the background: (spork|rspec|cucumber)(| .*)$/ do |command, args|
-  @background_script = run_in_background("#{command} #{args}")
+When /^I run this in the background: (spork|spec|cucumber)(| .*)$/ do |command, args|
+  @background_script = run_in_background(localized_command(command, args))
 end
 
 When /^I fire up a spork instance with "spork(.*)"$/ do |spork_opts|

data/features/support/env.rb

@@ -1,20 +1,17 @@
 require 'rubygems'
-require 'pathname'
 require 'fileutils'
 require 'forwardable'
 require 'tempfile'
-require 'rspec/expectations'
+require 'spec/expectations'
 require 'timeout'
+require 'spork'
 
 require(File.dirname(__FILE__) + '/background_job.rb')
 
-SPORK_ROOT    = Pathname.new(File.expand_path('../../', File.dirname(__FILE__)))
 class SporkWorld
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/spork')
   RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-  BINARY        = SPORK_ROOT + 'bin/spork'
-  SANDBOX_DIR   = SPORK_ROOT + "tmp/sandbox"
-  GEMFILES_ROOT = SPORK_ROOT + "features/gemfiles"
-  SPORK_LIBDIR  = SPORK_ROOT + "lib"
+  SANDBOX_DIR   = File.expand_path(File.join(File.dirname(__FILE__), '../../tmp/sandbox'))
   
   extend Forwardable
   def_delegators SporkWorld, :sandbox_dir, :spork_lib_dir
@@ -57,11 +54,23 @@ class SporkWorld
     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 = `env RUBYOPT= bundle exec #{command} 2> #{stderr_file.path}`
+      @last_stdout = `#{command} 2> #{stderr_file.path}`
       @last_exit_status = $?.exitstatus
     end
     @last_stderr = IO.read(stderr_file.path)
@@ -69,7 +78,7 @@ class SporkWorld
 
   def run_in_background(command)
     in_current_dir do
-      @background_job = BackgroundJob.run("env RUBYOPT= bundle exec " +  command)
+      @background_job = BackgroundJob.run(command)
     end
     @background_jobs << @background_job
     @background_job
@@ -84,11 +93,8 @@ class SporkWorld
     @background_jobs.clear
     @background_job = nil
   end
-end
-
-require(SPORK_ROOT + "features/support/bundler_helpers.rb")
-BundlerHelpers.set_gemfile(ENV["GEMFILE"])
 
+end
 
 World do
   SporkWorld.new

data/lib/spork.rb

@@ -30,7 +30,7 @@ module Spork
     # * +prevent_double_run+ - Pass false to disable double run prevention
     def each_run(prevent_double_run = true, &block)
       return if prevent_double_run && already_ran?(caller.first)
-      if state == :prefork
+      if @state == :using_spork
         each_run_procs << block
       else
         yield
@@ -47,23 +47,28 @@ module Spork
       after_each_run_procs << block
     end
 
+    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
+    def using_spork!
+      @state = :using_spork
+    end
+    
     def using_spork?
-      state != :not_using_spork
+      @state == :using_spork
     end
 
+    # Used by the server.  Returns the current state of Spork.
     def state
       @state ||= :not_using_spork
     end
     
     # Used by the server.  Called when loading the prefork blocks of the code.
     def exec_prefork(&block)
-      @state = :prefork
+      using_spork!
       yield
     end
     
     # Used by the server.  Called to run all of the prefork blocks.
     def exec_each_run(&block)
-      @state = :run
       activate_after_each_run_at_exit_hook
       each_run_procs.each { |p| p.call }
       each_run_procs.clear
@@ -83,9 +88,9 @@ module Spork
       
       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, &block)
+        def #{method_name}(*args)
           Spork.each_run(false) do
-            #{method_name_without_spork}(*args, &block)
+            #{method_name_without_spork}(*args)
           end
         end
       EOF
@@ -131,11 +136,7 @@ module Spork
       def expanded_caller(caller_line)
         file, line = caller_line.split(/:(\d+)/)
         line.gsub(/:.+/, '')
-        expanded = File.expand_path(file, Dir.pwd) + ":" + line
-        if ENV['OS'] == 'Windows_NT' # windows
-          expanded = expanded[2..-1]
-        end
-        expanded
+        File.expand_path(file, Dir.pwd) + ":" + line
       end
       
       def already_ran?(caller_script_and_line)
@@ -149,7 +150,6 @@ module Spork
       end
 
       def after_each_run_procs
-        spookie
         @after_each_run_procs ||= []
       end
   end

data/lib/spork/app_framework.rb

@@ -9,10 +9,7 @@ class Spork::AppFramework
       File.exist?("config/boot.rb") && File.read("config/boot.rb").include?('PADRINO')
     },
     :Rails => lambda {
-      File.exist?("config/environment.rb") && (
-        File.read("config/environment.rb").include?('RAILS_GEM_VERSION') ||
-        (File.exist?("config/application.rb") && File.read("config/application.rb").include?("Rails::Application"))
-      )
+      File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
     }
   } unless defined? SUPPORTED_FRAMEWORKS
   

data/lib/spork/app_framework/rails.rb

@@ -1,5 +1,118 @@
 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.map(&:to_sym).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.map(&:to_sym).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.map(&:to_sym).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
@@ -18,10 +131,6 @@ class Spork::AppFramework::Rails < Spork::AppFramework
     @boot_file ||= File.join(File.dirname(environment_file), 'boot')
   end
 
-  def application_file
-    @application_file ||= File.join(File.dirname(environment_file), 'application')
-  end
-
   def environment_contents
     @environment_contents ||= File.read(environment_file)
   end
@@ -30,7 +139,7 @@ class Spork::AppFramework::Rails < Spork::AppFramework
     @vendor ||= File.expand_path("vendor/rails", Dir.pwd)
   end
 
-  def deprecated_version
+  def version
     @version ||= (
       if /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/.match(environment_contents)
         $1
@@ -41,42 +150,9 @@ class Spork::AppFramework::Rails < Spork::AppFramework
   end
 
   def preload_rails
-    if deprecated_version && (not deprecated_version.match?(/^3/))
-      puts "This version of spork only supports Rails 3.0. To use spork with rails 2.3.x, downgrade to spork 0.8.x."
-      exit 1
-    end
-    require application_file
-    ::Rails.application
-    ::Rails::Engine.class_eval do
-      def eager_load!
-        # turn off eager_loading, all together
-      end
-    end
-    # Spork.trap_method(::AbstractController::Helpers::ClassMethods, :helper)
-    Spork.trap_method(::ActiveModel::Observing::ClassMethods, :instantiate_observers)
-    Spork.each_run { ActiveRecord::Base.establish_connection rescue nil } if Object.const_defined?(:ActiveRecord)
-
-
-    AbstractController::Helpers::ClassMethods.module_eval do
-      def helper(*args, &block)
-        ([args].flatten - [:all]).each do |arg|
-          next unless arg.is_a?(String)
-          filename = arg + "_helper"
-          unless ::ActiveSupport::Dependencies.search_for_file(filename)
-            # this error message must raise in the format such that LoadError#path returns the filename
-            raise LoadError.new("Missing helper file helpers/%s.rb" % filename)
-          end
-        end
-
-        Spork.each_run(false) do
-          modules_for_helpers(args).each do |mod|
-            add_template_helper(mod)
-          end
-
-          _helpers.module_eval(&block) if block_given?
-        end
-      end
-    end
+    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

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

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

@@ -0,0 +1,22 @@
+# This is a stub used to help Spork delay the loading of the real ApplicationController
+class ::ApplicationController < ActionController::Base
+  @@preloading = true
+  class << self
+    def inherited(klass)
+      (@_descendants ||= []) << klass if @@preloading
+      super
+    end
+
+    def reapply_inheritance!
+      @@preloading = false
+      Array(@_descendants).each do |descendant|
+        descendant.master_helper_module.send(:include, master_helper_module)
+        descendant.send(:default_helper_module!)
+
+        descendant.respond_to?(:reapply_inheritance!) && descendant.reapply_inheritance!
+      end
+    end
+  end
+end
+
+Spork.each_run { ApplicationController.reapply_inheritance! }

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

@@ -0,0 +1,3 @@
+# This is a stub used to help Spork delay the loading of the real ApplicationHelper
+module ::ApplicationHelper
+end

data/lib/spork/run_strategy.rb

@@ -28,7 +28,7 @@ class Spork::RunStrategy
 
   protected
     def self.factory(test_framework)
-      if RUBY_PLATFORM =~ /mswin|mingw|java/
+      if RUBY_PLATFORM =~ /mswin|mingw/
         Spork::RunStrategy::Magazine.new(test_framework)
       else
         Spork::RunStrategy::Forking.new(test_framework)

data/lib/spork/run_strategy/magazine.rb

@@ -4,14 +4,14 @@
 require 'drb'
 require 'rinda/ring'
 require 'win32/process' if RUBY_PLATFORM =~ /mswin|mingw/  and RUBY_VERSION < '1.9.1'
-require 'rubygems' # used for Gem.ruby
 
 $:.unshift(File.dirname(__FILE__))
 require 'magazine/magazine_slave'
 
+
 class Spork::RunStrategy::Magazine < Spork::RunStrategy
 
-  Slave_Id_Range = 1..2 # Ringserver uses id: 0. Slave use: 1..MAX_SLAVES
+  Slave_Id_Range = 1..3 # Ringserver uses id: 0. Slave use: 1..MAX_SLAVES
 
   def slave_max
     Slave_Id_Range.to_a.size
@@ -33,13 +33,14 @@ class Spork::RunStrategy::Magazine < Spork::RunStrategy
   end
 
   def start_Rinda_ringserver
-    app_name = "#{Gem.ruby} ring_server.rb"
-    spawn_process(app_name)
+    app_name = 'ruby ring_server.rb'
+    spawn_process(app_name)    
   end
 
   def fill_slave_pool
     Slave_Id_Range.each do |id|
       start_slave(id)
+      sleep 10
     end
     puts "  -- Starting to fill pool..."
     puts "     Wait until at least one slave is provided before running tests..."
@@ -49,21 +50,11 @@ class Spork::RunStrategy::Magazine < Spork::RunStrategy
 
   def start_slave(id)
     app_pwd = Dir.pwd  # path running app in
-    app = "#{Gem.ruby} magazine_slave_provider.rb #{id} '#{app_pwd}' #{@test_framework.short_name}"
+    app = "ruby magazine_slave_provider.rb #{id} '#{app_pwd}' #{@test_framework.short_name}"
     @pids[id] = spawn_process(app)
   end
 
   def spawn_process(app)
-
-    if RUBY_PLATFORM =~ /java/
-      # jruby 1.8 has no easy way to just spawn, so use a thread
-      Dir.chdir(@path) do
-        io = IO.popen app
-        Thread.new { puts io.read }        
-        return io.pid
-      end
-    end
-    
     if RUBY_VERSION < '1.9.1'
       Process.create( :app_name => app, :cwd => @path ).process_id
     else
@@ -76,24 +67,24 @@ class Spork::RunStrategy::Magazine < Spork::RunStrategy
   end
 
   def run(argv, stderr, stdout)
-        DRb.start_service
-        ts = Rinda::RingFinger.primary
-        if ts.read_all([:name, :MagazineSlave, nil, nil]).size > 0
-          print '  <-- take tuple'; stdout.flush
-          tuple = ts.take([:name, :MagazineSlave, nil, nil])
-          slave = tuple[2]
-          id = tuple[3]
-
-          puts "(#{slave.id_num}); slave.run..."; $stdout.flush
-          begin
-            slave.run(argv,stderr,stdout)
-            puts "   -- (#{slave.id_num});run done"; $stdout.flush
-          ensure
-            restart_slave(id)
-          end
-        else
-          puts '- NO tuple'; $stdout.flush
-        end
+    DRb.start_service
+    ts = Rinda::RingFinger.primary
+    if ts.read_all([:name, :MagazineSlave, nil, nil]).size > 0
+      print '  <-- take tuple'; stdout.flush
+      tuple = ts.take([:name, :MagazineSlave, nil, nil])
+      slave = tuple[2]
+      id = tuple[3]
+
+      puts "(#{slave.id_num}); slave.run..."; $stdout.flush
+      begin
+        slave.run(argv,stderr,stdout)
+        puts "   -- (#{slave.id_num});run done"; $stdout.flush
+      ensure
+        restart_slave(id)
+      end
+    else
+      puts '- NO tuple'; $stdout.flush
+    end
   end
 
   def restart_slave(id)
@@ -102,19 +93,9 @@ class Spork::RunStrategy::Magazine < Spork::RunStrategy
     start_slave(id)
   end
 
-  def windows?
-    ENV['OS'] == 'Windows_NT'
-  end
-  
   def kill_all_processes
 
-    @pids.each {|pid| 
-      if windows?
-        system("taskkill /f /pid #{pid}")
-      else
-        Process.kill(9, pid)
-      end
-    }
+    @pids.each {|pid| Process.kill(9, pid)}
     puts "\nKilling processes."; $stdout.flush
   end