milhouse-spork 0.7.5

data/features/steps/rails_steps.rb

@@ -0,0 +1,53 @@
+Given /^I am in a fresh rails project named "(.+)"$/ do |folder_name|
+  @current_dir = SporkWorld::SANDBOX_DIR
+  version_argument = ENV['RAILS_VERSION'] ? "_#{ENV['RAILS_VERSION']}_" : nil
+  # run("#{SporkWorld::RUBY_BINARY} #{%x{which rails}.chomp} #{folder_name}")
+  run([SporkWorld::RUBY_BINARY, '-I', Cucumber::LIBDIR, %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

@@ -0,0 +1,115 @@
+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 /^the contents of "([^\"]*)" are changed to:$/ do |file_name, file_content|
+  create_file(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|
+  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, args|
+  run(localized_command(command, args))
+end
+
+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|
+  @spork_server = run_in_background("#{SporkWorld::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{SporkWorld::BINARY} #{spork_opts}")
+
+  output = ""
+  begin
+    status = Timeout::timeout(15) do
+      # Something that should be interrupted if it takes too much time...
+      while line = @spork_server.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 spork window should output a line containing "(.+)"/ do |expected|
+  output = ""
+  begin
+    status = Timeout::timeout(5) do
+      # Something that should be interrupted if it takes too much time...
+      while line = @spork_server.stdout.gets
+        output << line
+        puts line
+        break if output.include?(expected)
+      end
+    end
+  rescue Timeout::Error
+    output.should include(expected)
+  end
+end
+
+When /^I type this in the spork window: "(.+)"/ do |line|
+  @spork_server.stdin.puts(line)
+  @spork_server.stdin.flush
+end
+
+
+Then /^the file "([^\"]*)" should include "([^\"]*)"$/ do |filename, content|
+  in_current_dir do
+    File.read(filename).should include(content)
+  end
+end
+
+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 (error output|output) should match \/(.+)\/$/ do |which, regex|
+  (which == "error output" ? last_stderr : last_stdout).should match(Regexp.new(regex))
+end
+
+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 (error output|output) should not contain "(.+)"$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
+end
+
+Then /^the (error output|output) should be empty$/ do |which|
+  (which == "error output" ? last_stderr : last_stdout).should == ""
+end
+
+Then /^the (error output|output) should be$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should == text
+end

data/features/support/background_job.rb

@@ -0,0 +1,63 @@
+class BackgroundJob
+  attr_reader :stdin, :stdout, :stderr, :pid
+  def initialize(pid, stdin, stdout, stderr)
+    @pid, @stdin, @stdout, @stderr = pid, stdin, stdout, stderr
+    ObjectSpace.define_finalizer(self) { kill }
+  end
+
+  def self.run(command)
+    command = sanitize_params(command) if command.is_a?(Array)
+    child_stdin, parent_stdin = IO::pipe
+    parent_stdout, child_stdout = IO::pipe
+    parent_stderr, child_stderr = IO::pipe
+
+    pid = Kernel.fork do
+      [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 }
+
+      exec command
+    end
+
+    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+    parent_stdin.sync = true
+
+    new(pid, parent_stdin, parent_stdout, parent_stderr)
+  end
+
+  def self.sanitize_params(params)
+    params.map { |p| p.gsub(' ', '\ ') }.join(" ")
+  end
+
+  def kill(signal = 'TERM')
+    if running?
+      Process.kill(Signal.list[signal], @pid)
+      true
+    end
+  end
+
+  def interrupt
+    kill('INT')
+  end
+
+  def running?
+    return false unless @pid
+    Process.getpgid(@pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  def wait(timeout = 1000)
+    Timeout.timeout(timeout) do
+      Process.wait(@pid)
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+end

data/features/support/env.rb

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

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/geminstaller.yml

@@ -0,0 +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' }

data/lib/spork/app_framework/rails.rb

@@ -0,0 +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
+  
+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/app_framework/unknown.rb

@@ -0,0 +1,6 @@
+# This is used if no supported appliction framework is detected
+class Spork::AppFramework::Unknown < Spork::AppFramework
+  def entry_point
+    nil
+  end
+end

data/lib/spork/app_framework.rb

@@ -0,0 +1,74 @@
+class Spork::AppFramework
+  # A hash of procs where the key is the class name, and the proc takes no arguments and returns true if it detects that said application framework is being used in the project.
+  # 
+  # The key :Rails maps to Spork::AppFramework::Rails
+  #
+  # This is used to reduce the amount of code needed to be loaded - only the detected application framework's support code is loaded.
+  SUPPORTED_FRAMEWORKS = {
+    :Rails => lambda {
+      File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
+    }
+  } unless defined? SUPPORTED_FRAMEWORKS
+  
+  def self.setup_autoload
+    ([:Unknown] + SUPPORTED_FRAMEWORKS.keys).each do |name|
+      autoload name, File.join(File.dirname(__FILE__), "app_framework", name.to_s.downcase)
+    end
+  end
+  
+  # Iterates through all SUPPORTED_FRAMEWORKS and returns the symbolic name of the project application framework detected.  Otherwise, returns :Unknown
+  def self.detect_framework_name
+    SUPPORTED_FRAMEWORKS.each do |key, value|
+      return key if value.call
+    end
+    :Unknown
+  end
+  
+  # Same as detect_framework_name, but returns an instance of the specific AppFramework class.
+  def self.detect_framework
+    name = detect_framework_name
+    self[name]
+  end
+  
+  # Initializes, stores, and returns a singleton instance of the named AppFramework.
+  #
+  # == Parameters
+  #
+  # # +name+ - A symbolic name of a AppFramework subclass
+  #
+  # == Example
+  #
+  #   Spork::AppFramework[:Rails]
+  def self.[](name)
+    instances[name] ||= const_get(name).new
+  end
+  
+  def self.short_name
+    name.gsub('Spork::AppFramework::', '')
+  end
+  
+  # If there is some stuff out of the box that the Spork can do to speed up tests without the test helper file being bootstrapped, this should return false.
+  def bootstrap_required?
+    entry_point.nil?
+  end
+  
+  # Abstract: The path to the file that loads the project environment, ie config/environment.rb.  Returns nil if there is none.
+  def entry_point
+    raise NotImplementedError
+  end
+  
+  def preload(&block)
+    yield
+  end
+  
+  def short_name
+    self.class.short_name
+  end
+  
+  protected
+    def self.instances
+      @instances ||= {}
+    end
+end
+
+Spork::AppFramework.setup_autoload

data/lib/spork/custom_io_streams.rb

@@ -0,0 +1,25 @@
+# This class is mainly used for testing.
+# When included (and used), it gives us an opportunity to stub out the output streams used for a given class
+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