spork 0.9.0.rc8-x86-mingw32

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|rspec|cucumber)(| .*)$/ do |command, args|
+  run("#{command} #{args}")
+end
+
+When /^I run this in the background: (spork|rspec|cucumber)(| .*)$/ do |command, args|
+  @background_script = run_in_background("#{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/bundler_helpers.rb

@@ -0,0 +1,41 @@
+require 'bundler'
+module BundlerHelpers
+  extend self
+  def install_bundle(dir)
+    Dir.chdir(dir) do
+      command = "env RUBYOPT= BUNDLE_GEMFILE=Gemfile bundle install"
+      system(command)
+      $?.exitstatus
+    end
+  end
+
+  def ensure_installed(dir)
+    gemfile_lock = dir + "/Gemfile.lock"
+    gemfile = dir + "/Gemfile"
+    bundle_environment = dir + "/.bundle/environment.rb"
+    case
+    when File.exist?(gemfile_lock) && File.mtime(gemfile) > File.mtime(gemfile_lock)
+      puts "Gemfile #{gemfile} has changed since it was locked. Re-locking..."
+      FileUtils.rm(gemfile_lock)
+      FileUtils.rm_rf(dir + "/.bundle")
+    when ! File.exist?(bundle_environment)
+      puts "Bundle #{gemfile} not installed.  Installing..."
+    when File.mtime(bundle_environment) < File.mtime(gemfile_lock)
+      puts "#{gemfile_lock} is newer than #{bundle_environment}.  Reinstalling"
+    else
+      return false
+    end
+    install_bundle(dir)
+  end
+
+  def expand_gemfile(gemfile)
+    possibilities = [File.expand_path(gemfile, Dir.pwd), SporkWorld::GEMFILES_ROOT + gemfile + "Gemfile"]
+    possibilities.detect {|f| File.exist?(f)} || raise(RuntimeError, %(Gemfile not found:\n #{possibilities * "\n"}))
+  end
+
+  def set_gemfile(gemfile)
+    gemfile = expand_gemfile(gemfile || "rails3.0")
+    ensure_installed(File.dirname(gemfile))
+    ENV["BUNDLE_GEMFILE"] = gemfile.to_s
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'pathname'
+require 'fileutils'
+require 'forwardable'
+require 'tempfile'
+require 'rspec/expectations'
+require 'timeout'
+
+require(File.dirname(__FILE__) + '/background_job.rb')
+
+SPORK_ROOT    = Pathname.new(File.expand_path('../../', File.dirname(__FILE__)))
+class SporkWorld
+  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"
+  
+  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 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_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("env RUBYOPT= bundle exec " +  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
+
+require(SPORK_ROOT + "features/support/bundler_helpers.rb")
+BundlerHelpers.set_gemfile(ENV["GEMFILE"])
+
+
+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/lib/spork.rb

@@ -0,0 +1,155 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+require 'pathname'
+module Spork
+  BINARY = File.expand_path(File.dirname(__FILE__) + '/../bin/spork')
+  LIBDIR = Pathname.new(File.expand_path(File.dirname(__FILE__)))
+
+  autoload :Server,        (LIBDIR + 'spork/server').to_s
+  autoload :TestFramework, (LIBDIR + 'spork/test_framework').to_s
+  autoload :AppFramework,  (LIBDIR + 'spork/app_framework').to_s
+  autoload :RunStrategy,   (LIBDIR + 'spork/run_strategy').to_s
+  autoload :Runner,        (LIBDIR + 'spork/runner').to_s
+  autoload :Forker,        (LIBDIR + 'spork/forker').to_s
+  autoload :Diagnoser,     (LIBDIR + 'spork/diagnoser').to_s
+  autoload :GemHelpers,    (LIBDIR + 'spork/gem_helpers').to_s
+
+  class << self
+    # Run a block, during prefork mode.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def prefork(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
+      yield
+    end
+    
+    # Run a block AFTER the fork occurs.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +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
+        each_run_procs << block
+      else
+        yield
+      end
+    end
+    
+    # Run a block after specs are run.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def after_each_run(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
+      after_each_run_procs << block
+    end
+
+    def using_spork?
+      state != :not_using_spork
+    end
+
+    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
+      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
+      yield if block_given?
+    end
+    
+    # Used by the server.  Called to run all of the after_each_run blocks.
+    def exec_after_each_run
+      # processes in reverse order similar to at_exit
+      while p = after_each_run_procs.pop; p.call; end
+      true
+    end
+
+    # Traps an instance method of a class (or module) so any calls to it don't actually run until Spork.exec_each_run
+    def trap_method(klass, method_name)
+      method_name_without_spork, method_name_with_spork = alias_method_names(method_name, :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)
+          Spork.each_run(false) do
+            #{method_name_without_spork}(*args, &block)
+          end
+        end
+      EOF
+    end
+    
+    # Same as trap_method, but for class methods instead
+    def trap_class_method(klass, method_name)
+      trap_method((class << klass; self; end), method_name)
+    end
+    
+    def detect_and_require(subfolder)
+      ([LIBDIR.to_s] + other_spork_gem_load_paths).uniq.each do |gem_path|
+        Dir.glob(File.join(gem_path, subfolder)).each { |file| require file }
+      end
+    end
+
+    # This method is used to auto-discover peer plugins such as spork-testunit.
+    def other_spork_gem_load_paths
+      @other_spork_gem_load_paths ||= Spork::GemHelpers.latest_load_paths.grep(/spork/).select do |g|
+        not g.match(%r{/spork-[0-9\-.]+/lib}) # don't include other versions of spork
+      end
+    end
+
+    private
+      def activate_after_each_run_at_exit_hook
+        Kernel.module_eval do
+          def at_exit(&block)
+            Spork.after_each_run(false, &block)
+          end
+        end
+      end
+
+      def alias_method_names(method_name, feature)
+        /^(.+?)([\?\!]{0,1})$/.match(method_name.to_s)
+        ["#{$1}_without_spork#{$2}", "#{$1}_with_spork#{$2}"]
+      end
+      
+      def already_ran
+        @already_ran ||= []
+      end
+      
+      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
+      end
+      
+      def already_ran?(caller_script_and_line)
+        return true if already_ran.include?(expanded_caller(caller_script_and_line))
+        already_ran << expanded_caller(caller_script_and_line)
+        false
+      end
+      
+      def each_run_procs
+        @each_run_procs ||= []
+      end
+
+      def after_each_run_procs
+        @after_each_run_procs ||= []
+      end
+  end
+end