timcharper-spork 0.5.10 → 0.6.0

data/features/rspec_rails_integration.feature

@@ -68,6 +68,7 @@ Feature: Rails Integration
 
 
   Scenario: Running spork with a rails app and a non-standard port
+    Given this scenario is pending until rspec releases a version that supports --port
     Given a file named "spec/did_it_work_spec.rb" with:
     """
     describe "Did it work?" do

data/features/steps/general_steps.rb

@@ -0,0 +1,3 @@
+Given /^this scenario is pending.+/ do
+  pending
+end

data/lib/spork/app_framework.rb

@@ -54,7 +54,7 @@ class Spork::AppFramework
   
   # 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 NotImplemented
+    raise NotImplementedError
   end
   
   def preload(&block)

data/lib/spork/run_strategy/forking.rb

@@ -0,0 +1,30 @@
+class Spork::RunStrategy::Forking < Spork::RunStrategy
+  def self.available?
+    Kernel.respond_to?(:fork)
+  end
+
+  def run(argv, stderr, stdout)
+    abort if running?
+
+    @child = ::Spork::Forker.new do
+      $stdout, $stderr = stdout, stderr
+      load test_framework.helper_file
+      Spork.exec_each_run
+      test_framework.run_tests(argv, stderr, stdout)
+    end
+    @child.result
+  end
+
+  def abort
+    @child && @child.abort
+  end
+
+  def preload
+    test_framework.preload
+  end
+
+  def running?
+    @child && @child.running?
+  end
+
+end

data/lib/spork/run_strategy.rb

@@ -0,0 +1,40 @@
+class Spork::RunStrategy
+  attr_reader :test_framework
+  @@run_strategies = []
+
+  def initialize(test_framework)
+    @test_framework = test_framework
+  end
+
+  def preload
+    raise NotImplementedError
+  end
+
+  def run(argv, input, output)
+    raise NotImplementedError
+  end
+
+  def cleanup
+    raise NotImplementedError
+  end
+
+  def running?
+    raise NotImplementedError
+  end
+
+  def abort
+    raise NotImplementedError
+  end
+
+  protected
+    def self.factory(test_framework)
+      Spork::RunStrategy::Forking.new(test_framework)
+    end
+
+    def self.inherited(subclass)
+      @@run_strategies << subclass
+    end
+
+end
+
+Dir[File.dirname(__FILE__) + "/run_strategy/*.rb"].each { |file| require file }

data/lib/spork/runner.rb

@@ -1,10 +1,12 @@
 require 'optparse'
 require 'spork/server'
+require 'spork/test_framework'
+require 'spork/run_strategy'
 
 module Spork
   # This is used by bin/spork. It's wrapped in a class because it's easier to test that way.
   class Runner
-    attr_reader :server
+    attr_reader :test_framework
     
     def self.run(args, output, error)
       self.new(args, output, error).run
@@ -30,74 +32,49 @@ module Spork
       if @options[:help]
         @output.puts opt
         @output.puts
-        @output.puts supported_servers_text
+        @output.puts supported_test_frameworks_text
         exit(0)
       end
     end
     
-    def supported_servers_text
+    def supported_test_frameworks_text
       text = StringIO.new
       
       text.puts "Supported test frameworks:"
-      text.puts Spork::Server.supported_servers.sort { |a,b| a.server_name <=> b.server_name }.map { |s| (s.available? ? '(*) ' : '( ) ') + s.server_name }
+      text.puts Spork::TestFramework.supported_test_frameworks.sort { |a,b| a.short_name <=> b.short_name }.map { |s| (s.available? ? '(*) ' : '( ) ') + s.short_name }
       text.puts "\nLegend: ( ) - not detected in project   (*) - detected\n"
       text.string
     end
     
     # Returns a server for the specified (or the detected default) testing framework.  Returns nil if none detected, or if the specified is not supported or available.
-    def find_server
-      if options[:server_matcher]
-        @server = Spork::Server.supported_servers(options[:server_matcher]).first
-        unless @server
-          @error.puts <<-ERROR
-#{options[:server_matcher].inspect} didn't match a supported test framework.
-
-#{supported_servers_text}
-          ERROR
-          return
-        end
-        
-        unless @server.available?
-          @error.puts  <<-USEFUL_ERROR
-I can't find the helper file #{@server.helper_file} for the #{@server.server_name} testing framework.
-Are you running me from the project directory?
-          USEFUL_ERROR
-          return
-        end
-      else
-        @server = Spork::Server.available_servers.first
-        if @server.nil?
-          @error.puts  <<-USEFUL_ERROR
-I can't find any testing frameworks to use.
-Are you running me from a project directory?
-          USEFUL_ERROR
-          return
-        end
-      end
-      @server
+    def find_test_framework
+      Spork::TestFramework.factory(@output, @error, options[:server_matcher])
+    rescue Spork::TestFramework::NoFrameworksAvailable => e
+      @error.puts e.message
+    rescue Spork::TestFramework::FactoryException => e
+      @error.puts "#{e.message}\n\n#{supported_test_frameworks_text}"
     end
     
     def run
-      return false unless find_server
+      return false unless test_framework = find_test_framework
       ENV["DRB"] = 'true'
-      @error.puts "Using #{server.server_name}"
+      @error.puts "Using #{test_framework.short_name}"
       @error.flush
 
-      server.port = options[:port]
-
       case
       when options[:bootstrap]
-        server.bootstrap
+        test_framework.bootstrap
       when options[:diagnose]
         require 'spork/diagnoser'
         
-        Spork::Diagnoser.install_hook!(server.entry_point)
-        server.preload
+        Spork::Diagnoser.install_hook!(test_framework.entry_point)
+        test_framework.preload
         Spork::Diagnoser.output_results(@output)
         return true
       else
-        return(false) unless server.preload
-        server.run
+        run_strategy = Spork::RunStrategy.factory(test_framework)
+        return(false) unless run_strategy.preload
+        Spork::Server.run(:port => @options[:port] || test_framework.default_port, :run_strategy => run_strategy)
         return true
       end
     end

data/lib/spork/server.rb

@@ -8,78 +8,16 @@ require 'spork/app_framework.rb'
 #
 # (This was originally based off of spec_server.rb from rspec-rails (David Chelimsky), which was based on Florian Weber's TDDMate)
 class Spork::Server
-  @@supported_servers = []
-  
-  LOAD_PREFERENCE = ['RSpec', 'Cucumber']
-  BOOTSTRAP_FILE = File.dirname(__FILE__) + "/../../assets/bootstrap.rb"
-  
+  attr_reader :run_strategy
   include Spork::CustomIOStreams
   
-  # Abstract method: returns the servers port.  Override this to return the port that should be used by the test framework.
-  def self.port
-    raise NotImplemented
-  end
-  
-  # Abstract method: returns the entry file that loads the testing environment, such as spec/spec_helper.rb.
-  def self.helper_file
-    raise NotImplemented
-  end
-  
-  # Convenience method that turns the class name without the namespace
-  def self.server_name
-    self.name.gsub('Spork::Server::', '')
+  def initialize(options = {})
+    @run_strategy = options[:run_strategy]
+    @port = options[:port]
   end
   
-  # Returns a list of all testing servers that have detected their testing framework being used in the project.
-  def self.available_servers
-    supported_servers.select { |s| s.available? }
-  end
-  
-  # Returns a list of all servers that have been implemented (it keeps track of them automatically via Class.inherited)
-  def self.supported_servers(starting_with = nil)
-    @@supported_servers.sort! { |a,b| a.load_preference_index <=> b.load_preference_index }
-    return @@supported_servers if starting_with.nil?
-    @@supported_servers.select do |s|
-      s.server_name.match(/^#{Regexp.escape(starting_with)}/i)
-    end
-  end
-  
-  # Returns true if the testing frameworks helper file exists.  Override if this is not sufficient to detect your testing framework.
-  def self.available?
-    File.exist?(helper_file)
-  end
-  
-  # Used to specify
-  def self.load_preference_index
-    LOAD_PREFERENCE.index(server_name) || LOAD_PREFERENCE.length
-  end
-  
-  # Detects if the test helper has been bootstrapped.
-  def self.bootstrapped?
-    File.read(helper_file).include?("Spork.prefork")
-  end
-  
-  # Bootstraps the current test helper file by prepending a Spork.prefork and Spork.each_run block at the beginning.
-  def self.bootstrap
-    if bootstrapped?
-      stderr.puts "Already bootstrapped!"
-      return
-    end
-    stderr.puts "Bootstrapping #{helper_file}."
-    contents = File.read(helper_file)
-    bootstrap_code = File.read(BOOTSTRAP_FILE)
-    File.open(helper_file, "wb") do |f|
-      f.puts bootstrap_code
-      f.puts contents
-    end
-    
-    stderr.puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
-    true
-  end
-  
-  def self.run
-    return unless available?
-    new.listen
+  def self.run(options = {})
+    new(options).listen
   end
   
   # Sets up signals and starts the DRb service. If it's successful, it doesn't return. Not ever.  You don't need to override this.
@@ -93,18 +31,8 @@ class Spork::Server
     DRb.thread.join
   end
   
-  def port
-    self.class.instance_variable_get("@port") || self.class.port
-  end
+  attr_accessor :port
 
-  def self.port= p
-    @port = p
-  end
-  
-  def helper_file
-    self.class.helper_file
-  end
-  
   # This is the public facing method that is served up by DRb.  To use it from the client side (in a testing framework):
   # 
   #   DRb.start_service("druby://localhost:0") # this allows Ruby to do some magical stuff so you can pass an output stream over DRb.
@@ -114,66 +42,10 @@ class Spork::Server
   #
   # When implementing a test server, don't override this method: override run_tests instead.
   def run(argv, stderr, stdout)
-    abort if running?
-    
-    @child = ::Spork::Forker.new do
-      $stdout, $stderr = stdout, stderr
-      Spork.exec_each_run { load helper_file }
-      run_tests(argv, stderr, stdout)
-    end
-    @child.result
+    run_strategy.run(argv, stderr, stdout)
   end
   
-  # returns whether or not the child (a test run) is running right now.
-  def running?
-    @child && @child.running?
-  end
-  
-  protected
-    # Abstract method: here is where the server runs the tests.
-    def run_tests(argv, input, output)
-      raise NotImplemented
-    end
-  
   private
-    def self.inherited(subclass)
-      @@supported_servers << subclass
-    end
-    
-    def self.framework
-      @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?
-          stderr.puts "#{helper_file} has not been bootstrapped.  Run spork --bootstrap to do so."
-          stderr.flush
-        
-          if framework.bootstrap_required?
-            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
-      
-        framework.preload do
-          if bootstrapped?
-            stderr.puts "Loading Spork.prefork block..."
-            stderr.flush
-            load(helper_file)
-          end
-        end  
-      end
-      true
-    end
-    
     def restart
       stderr.puts "restarting"
       stderr.flush
@@ -183,12 +55,8 @@ class Spork::Server
       exec(command_line)
     end
     
-    def abort
-      @child && @child.abort
-    end
-    
     def sig_int_received
-      if running?
+      if run_strategy.running?
         abort
         stderr.puts "Running tests stopped.  Press CTRL-C again to stop the server."
         stderr.flush
@@ -197,5 +65,3 @@ class Spork::Server
       end
     end
 end
-
-Dir[File.dirname(__FILE__) + "/server/*.rb"].each { |file| require file }

data/lib/spork/test_framework/cucumber.rb

@@ -0,0 +1,24 @@
+class Spork::TestFramework::Cucumber < Spork::TestFramework
+  DEFAULT_PORT = 8990
+  HELPER_FILE = File.join(Dir.pwd, "features/support/env.rb")
+
+  class << self
+    # REMOVE WHEN SUPPORT FOR 0.3.95 AND EARLIER IS DROPPED
+    attr_accessor :mother_object
+  end
+
+  def preload
+    require 'cucumber'
+    begin
+      @step_mother = ::Cucumber::StepMother.new
+      @step_mother.load_programming_language('rb')
+    rescue NoMethodError => pre_cucumber_0_4 # REMOVE WHEN SUPPORT FOR PRE-0.4 IS DROPPED
+      @step_mother = Spork::Server::Cucumber.mother_object
+    end
+    super
+  end
+
+  def run_tests(argv, stderr, stdout)
+    ::Cucumber::Cli::Main.new(argv, stdout, stderr).execute!(@step_mother)
+  end
+end

data/lib/spork/test_framework/rspec.rb

@@ -0,0 +1,14 @@
+class Spork::TestFramework::RSpec < Spork::TestFramework
+  DEFAULT_PORT = 8989
+  HELPER_FILE = File.join(Dir.pwd, "spec/spec_helper.rb")
+
+  def run_tests(argv, stderr, stdout)
+    ::Spec::Runner::CommandLine.run(
+      ::Spec::Runner::OptionParser.parse(
+        argv,
+        stderr,
+        stdout
+      )
+    )
+  end
+end

data/lib/spork/test_framework.rb

@@ -0,0 +1,167 @@
+class Spork::TestFramework
+  LOAD_PREFERENCE = ['RSpec', 'Cucumber']
+  BOOTSTRAP_FILE = File.dirname(__FILE__) + "/../../assets/bootstrap.rb"
+
+  @@supported_test_frameworks = []
+  attr_reader :stdout, :stderr
+
+  class FactoryException < Exception; end
+
+  class NoFrameworksAvailable < FactoryException
+    def message
+      "I can't find any testing frameworks to use.  Are you running me from a project directory?"
+    end
+  end
+
+  class FrameworkNotAvailable < FactoryException
+    def initialize(framework)
+      @framework = framework
+    end
+
+    def message
+      "I can't find the file #{e.test_framework.helper_file} for the #{e.test_framework.short_name} testing framework.\nAre you running me from the project directory?"
+    end
+  end
+
+  class NoFrameworkMatched < FactoryException
+    def initialize(beginning_with)
+      @beginning_with = beginning_with
+    end
+
+    def message
+      "Couldn't find a supported test framework that begins with '#{@beginning_with}'"
+    end
+  end
+
+  def initialize(stdout = STDOUT, stderr = STDERR)
+    @stdout, @stderr = stdout, stderr
+  end
+
+  def self.factory(output = STDOUT, error = STDERR, beginning_with = nil)
+    if beginning_with
+      @klass = supported_test_frameworks(beginning_with).first
+      raise(NoFrameworkMatched.new(beginning_with)) if @klass.nil?
+      raise(FrameworkNotAvailable.new(@klass)) unless @klass.available?
+    else
+      @klass = available_test_frameworks.first
+      raise(NoFrameworksAvailable.new) unless @klass
+    end
+    @klass.new(output, error)
+  end
+
+  def self.helper_file
+    self::HELPER_FILE
+  end
+
+  def self.default_port
+    (ENV["#{short_name.upcase}_DRB"] || self::DEFAULT_PORT).to_i
+  end
+
+  def self.short_name
+    self.name.gsub('Spork::TestFramework::', '')
+  end
+
+  # Returns a list of all testing servers that have detected their testing framework being used in the project.
+  def self.available_test_frameworks
+    supported_test_frameworks.select { |s| s.available? }
+  end
+
+  # Returns a list of all servers that have been implemented (it keeps track of them automatically via Class.inherited)
+  def self.supported_test_frameworks(starting_with = nil)
+    @@supported_test_frameworks.sort! { |a,b| a.load_preference_index <=> b.load_preference_index }
+    return @@supported_test_frameworks if starting_with.nil?
+    @@supported_test_frameworks.select do |s|
+      s.short_name.match(/^#{Regexp.escape(starting_with)}/i)
+    end
+  end
+
+  def short_name
+    self.class.short_name
+  end
+
+  def helper_file
+    self.class.helper_file
+  end
+
+  # Detects if the test helper has been bootstrapped.
+  def bootstrapped?
+    File.read(helper_file).include?("Spork.prefork")
+  end
+
+  # Bootstraps the current test helper file by prepending a Spork.prefork and Spork.each_run block at the beginning.
+  def bootstrap
+    if bootstrapped?
+      stderr.puts "Already bootstrapped!"
+      return
+    end
+    stderr.puts "Bootstrapping #{helper_file}."
+    contents = File.read(helper_file)
+    bootstrap_code = File.read(BOOTSTRAP_FILE)
+    File.open(helper_file, "wb") do |f|
+      f.puts bootstrap_code
+      f.puts contents
+    end
+
+    stderr.puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
+    true
+  end
+
+  # Returns true if the testing frameworks helper file exists.  Override if this is not sufficient to detect your testing framework.
+  def self.available?
+    File.exist?(helper_file)
+  end
+
+  # Used to specify
+  def self.load_preference_index
+    LOAD_PREFERENCE.index(short_name) || LOAD_PREFERENCE.length
+  end
+
+  def preload
+    Spork.exec_prefork do
+      unless bootstrapped?
+        stderr.puts "#{helper_file} has not been bootstrapped.  Run spork --bootstrap to do so."
+        stderr.flush
+
+        if framework.bootstrap_required?
+          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
+
+      framework.preload do
+        if bootstrapped?
+          stderr.puts "Loading Spork.prefork block..."
+          stderr.flush
+          load(helper_file)
+        end
+      end
+    end
+    true
+  end
+
+  def run_tests(argv, stderr, stdout)
+    raise NotImplementedError
+  end
+
+  def entry_point
+    bootstrapped? ? helper_file : framework.entry_point
+  end
+
+  def default_port
+    self.class.default_port
+  end
+
+  protected
+    def self.inherited(subclass)
+      @@supported_test_frameworks << subclass
+    end
+
+    def framework
+      @framework ||= Spork::AppFramework.detect_framework
+    end
+end
+
+Spork.detect_and_require('spork/test_framework/*.rb')

data/lib/spork.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 module Spork
   BINARY = File.expand_path(File.dirname(__FILE__) + '/../bin/spork')
-  LIBDIR = File.expand_path(File.dirname(__FILE__))
+  LIBDIR = File.expand_path("..", File.dirname(__FILE__))
 
   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.
@@ -70,6 +70,12 @@ module Spork
       trap_method((class << klass; self; end), method_name)
     end
     
+    def detect_and_require(subfolder)
+      ([LIBDIR] + Gem.latest_load_paths.grep(/spork/)).uniq.each do |gem_path|
+        Dir.glob(File.join(gem_path, subfolder)).each { |file| require file }
+      end
+    end
+
     private
       def alias_method_names(method_name, feature)
         /^(.+?)([\?\!]{0,1})$/.match(method_name.to_s)

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'spec'
 
 unless $spec_helper_loaded
   $spec_helper_loaded = true
@@ -9,7 +8,6 @@ unless $spec_helper_loaded
   
   require 'spork'
   require 'spork/runner.rb'
-  require 'spork/server.rb'
   require 'spork/diagnoser.rb'
   require 'stringio'
   require 'fileutils'
@@ -34,7 +32,11 @@ unless $spec_helper_loaded
         File.open(filename, 'wb') { |f| f << contents }
       end
     end
-  
+
+    def create_helper_file(test_framework = FakeFramework)
+      create_file(test_framework.helper_file, "# stub spec helper file")
+    end
+
     def in_current_dir(&block)
       Dir.chdir(current_dir, &block)
     end
@@ -104,4 +106,6 @@ unless $spec_helper_loaded
       end
     end
   end
+
+  Dir.glob(File.dirname(__FILE__) + "/support/*.rb").each { |f| require(f) }
 end

data/spec/spork/run_strategy/forking_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::RunStrategy::Forking do
+  before(:each) do
+    @fake_framework = FakeFramework.new
+    @run_strategy = Spork::RunStrategy::Forking.new(@fake_framework)
+
+  end
+
+  it "returns the result of the run_tests method from the forked child" do
+    create_helper_file
+    @fake_framework.stub!(:run_tests).and_return("tests were ran")
+    @run_strategy.run("test", STDOUT, STDIN).should == "tests were ran"
+  end
+
+  it "aborts the current running thread when another run is started" do
+    create_helper_file
+    @fake_framework.wait_time = 0.25
+    first_run = Thread.new { @run_strategy.run("test", STDOUT, STDIN).should == nil }
+    sleep(0.05)
+    @run_strategy.run("test", STDOUT, STDIN).should == true
+
+    # wait for the first to finish
+    first_run.join
+  end
+
+  it "can abort the current run" do
+    create_helper_file
+    @fake_framework.wait_time = 5
+    started_at = Time.now
+    first_run = Thread.new { @run_strategy.run("test", STDOUT, STDIN).should == true }
+    sleep(0.05)
+    @run_strategy.send(:abort)
+    sleep(0.01) while @run_strategy.running?
+
+    (Time.now - started_at).should < @fake_framework.wait_time
+  end
+end

data/spec/spork/runner_spec.rb

@@ -1,60 +1,54 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Spork::Runner do
+  def use_test_server(klass = Spork::TestFramework::RSpec)
+    @test_framework = klass.new
+    Spork::TestFramework.stub!(:factory).and_return(@test_framework)
+  end
+
   before(:each) do
     @out, @err = StringIO.new, StringIO.new
   end
   
   it "finds a matching server with a prefix" do
-    Spork::Runner.new(["rs"], @out, @err).find_server.should == Spork::Server::RSpec
+    Spork::Runner.new(["rs"], @out, @err).find_test_framework.class.should == Spork::TestFramework::RSpec
   end
   
   it "shows an error message if no matching server was found" do
     Spork::Runner.new(["argle_bargle"], @out, @err).run.should == false
-    @err.string.should include(%("argle_bargle" didn't match a supported test framework))
-  end
-  
-  it "defaults to use rspec over cucumber" do
-    Spork::Server::RSpec.stub!(:available?).and_return(true)
-    Spork::Server::Cucumber.stub!(:available?).and_return(true)
-    Spork::Runner.new([], @out, @err).find_server.should == Spork::Server::RSpec
-  end
-  
-  it "defaults to use cucumber when rspec not available" do
-    Spork::Server::RSpec.stub!(:available?).and_return(false)
-    Spork::Server::Cucumber.stub!(:available?).and_return(true)
-    Spork::Runner.new([], @out, @err).find_server.should == Spork::Server::Cucumber
+    @err.string.should include(%(Couldn't find a supported test framework that begins with 'argle_bargle'))
   end
   
   it "bootstraps a server when -b is passed in" do
-    Spork::Server::RSpec.stub!(:available?).and_return(true)
-    Spork::Server::RSpec.should_receive(:bootstrap).and_return(true)
+    use_test_server
+    @test_framework.should_receive(:bootstrap)
     Spork::Runner.new(['rspec', '-b'], @out, @err).run
   end
   
   it "aborts if it can't preload" do
-    Spork::Server::RSpec.stub!(:available?).and_return(true)
-    Spork::Server::RSpec.should_receive(:preload).and_return(false)
-    Spork::Server::RSpec.should_not_receive(:run)
+    use_test_server
+    @test_framework.should_receive(:preload).and_return(false)
+    Spork::Server.should_not_receive(:run)
     Spork::Runner.new(['rspec'], @out, @err).run
   end
   
   it "runs the server if all is well" do
-    Spork::Server::RSpec.stub!(:available?).and_return(true)
-    Spork::Server::RSpec.should_receive(:preload).and_return(true)
-    Spork::Server::RSpec.should_receive(:run).and_return(true)
+    use_test_server
+    @test_framework.should_receive(:preload).and_return(true)
+    Spork::Server.should_receive(:run)
     Spork::Runner.new(['rspec'], @out, @err).run
     @err.string.should include("Using RSpec")
   end
   
   it "outputs a list of supported servers, along with supported asterisk" do
-    Spork::Server.stub!(:supported_servers).and_return([Spork::Server::RSpec, Spork::Server::Cucumber])
-    Spork::Server::RSpec.stub!(:available?).and_return(true)
-    Spork::Server::Cucumber.stub!(:available?).and_return(false)
+    Spork::Server.stub!(:supported_test_frameworks).and_return([Spork::TestFramework::RSpec, Spork::TestFramework::Cucumber])
+    Spork::TestFramework::RSpec.stub!(:available?).and_return(true)
+    Spork::TestFramework::Cucumber.stub!(:available?).and_return(false)
     
-    Spork::Runner.new(['rspec'], @out, @err).supported_servers_text.should == <<-EOF
+    Spork::Runner.new(['rspec'], @out, @err).supported_test_frameworks_text.should == <<-EOF
 Supported test frameworks:
 ( ) Cucumber
+( ) FakeFramework
 (*) RSpec
 
 Legend: ( ) - not detected in project   (*) - detected

data/spec/spork/server_spec.rb

@@ -1,141 +1,15 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-
-class FakeServer < Spork::Server
-  attr_accessor :wait_time
-  
-  include Spork::TestIOStreams
-  
-  def self.helper_file
-    SPEC_TMP_DIR + "/fake/test_helper.rb"
-  end
-  
-  def self.port
-    1000
-  end
-  
-  def run_tests(argv, input, output)
-    sleep(@wait_time || 0.5)
-    true
-  end
-end
-
 describe Spork::Server do
-  describe ".available_servers" do
-    before(:each) do
-      Spork::Server.supported_servers.each { |s| s.stub!(:available?).and_return(false) }
-    end
-    
-    it "returns a list of all available servers" do
-      Spork::Server.available_servers.should == []
-      Spork::Server::RSpec.stub!(:available?).and_return(true)
-      Spork::Server.available_servers.should == [Spork::Server::RSpec]
-    end
-    
-    it "returns rspec before cucumber when both are available" do
-      Spork::Server::RSpec.stub!(:available?).and_return(true)
-      Spork::Server::Cucumber.stub!(:available?).and_return(true)
-      Spork::Server.available_servers.should == [Spork::Server::RSpec, Spork::Server::Cucumber]
-    end
-  end
-  
-  describe ".supported_servers" do
-    it "returns all defined servers" do
-      Spork::Server.supported_servers.should include(Spork::Server::RSpec)
-      Spork::Server.supported_servers.should include(Spork::Server::Cucumber)
-    end
-    
-    it "returns a list of servers matching a case-insensitive prefix" do
-      Spork::Server.supported_servers("rspec").should == [Spork::Server::RSpec]
-      Spork::Server.supported_servers("rs").should == [Spork::Server::RSpec]
-      Spork::Server.supported_servers("cuc").should == [Spork::Server::Cucumber]
-    end
-  end
-  
   describe "a fake server" do
-    def create_helper_file
-      create_file(FakeServer.helper_file, "# stub spec helper file")
-    end
-  
     before(:each) do
-      @fake = FakeServer.new
-    end
-  
-    it "should be available when the helper_file exists" do
-      FakeServer.available?.should == false
-      create_helper_file
-      FakeServer.available?.should == true
-    end
-  
-    it "has a name" do
-      FakeServer.server_name.should == "FakeServer"
-    end
-  
-    it "tells if it's testing framework is being used" do
-      Spork::Server.available_servers.should_not include(FakeServer)
-      create_helper_file
-      Spork::Server.available_servers.should include(FakeServer)
-    end
-  
-    it "recognizes if the helper_file has been bootstrapped" do
-      bootstrap_contents = File.read(FakeServer::BOOTSTRAP_FILE)
-      File.stub!(:read).with(FakeServer.helper_file).and_return("")
-      FakeServer.bootstrapped?.should == false
-      File.stub!(:read).with(FakeServer.helper_file).and_return(bootstrap_contents)
-      FakeServer.bootstrapped?.should == true
-    end
-  
-    it "bootstraps a file" do
-      create_helper_file
-      FakeServer.bootstrap
-    
-      $test_stderr.string.should include("Bootstrapping")
-      $test_stderr.string.should include("Edit")
-      $test_stderr.string.should include("favorite text editor")
-    
-      File.read(FakeServer.helper_file).should include(File.read(FakeServer::BOOTSTRAP_FILE))
+      @fake_run_strategy = FakeRunStrategy.new
+      @server = Spork::Server.new(:run_strategy => @fake_run_strategy)
     end
-  
-    it "aborts the current running thread when another run is started" do
-      create_helper_file
-      @fake.wait_time = 0.25
-      first_run = Thread.new { @fake.run("test", STDOUT, STDIN).should == nil }
-      sleep(0.05)
-      @fake.run("test", STDOUT, STDIN).should == true
     
-      # wait for the first to finish
-      first_run.join
-    end
-  
-    it "can abort the current run" do
-      create_helper_file
-      @fake.wait_time = 5
-      started_at = Time.now
-      first_run = Thread.new { @fake.run("test", STDOUT, STDIN).should == true }
-      sleep(0.05)
-      @fake.send(:abort)
-      sleep(0.01) while @fake.running?
-      
-      (Time.now - started_at).should < @fake.wait_time
-    end
-    
-    it "returns the result of the run_tests method from the forked child" do
-      create_helper_file
-      @fake.stub!(:run_tests).and_return("tests were ran")
-      @fake.run("test", STDOUT, STDIN).should == "tests were ran"
-    end
-
     it "accepts a port" do
-      create_helper_file
-      @fake.class.port = 12345
-      @fake.port.should == 12345
-    end
-
-    it "falls back to a default port" do
-      create_helper_file
-      @fake.class.port = nil
-      @fake.port.should == FakeServer.port
+      @server.port = 12345
+      @server.port.should == 12345
     end
-
   end
 end

data/spec/spork/test_framework/cucumber_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + "/../test_framework_spec"
+
+describe Spork::TestFramework::Cucumber do
+  before(:each) do
+    @klass = Spork::TestFramework::Cucumber
+    @server = @klass.new
+  end
+
+  it_should_behave_like "a TestFramework"
+end

data/spec/spork/test_framework/rspec_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + "/../test_framework_spec"
+
+describe Spork::TestFramework::RSpec do
+  before(:each) do
+    @klass = Spork::TestFramework::RSpec
+  end
+
+  it_should_behave_like "a TestFramework"
+end

data/spec/spork/test_framework_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "a TestFramework", :shared => true do
+  describe ".default_port" do
+    it "uses the DEFAULT_PORT when the environment variable is not set" do
+      @klass.default_port.should == @klass::DEFAULT_PORT
+    end
+
+    it 'uses ENV["#{short_name.upcase}_DRB"] as port if present' do
+      env_name = "#{@klass.short_name.upcase}_DRB"
+      orig, ENV[env_name] = ENV[env_name], "9000"
+      begin
+        @klass.default_port.should == 9000
+      ensure
+        ENV[env_name] = orig
+      end
+    end
+  end
+
+  describe ".helper_file" do
+    it "returns ::HELPER_FILE for the TestFramework" do
+      @klass.helper_file.should == @klass::HELPER_FILE
+    end
+  end
+end
+
+describe Spork::TestFramework do
+
+  before(:each) do
+    @fake = FakeFramework.new
+  end
+
+  describe ".available_test_frameworks" do
+    before(:each) do
+      Spork::TestFramework.supported_test_frameworks.each { |s| s.stub!(:available?).and_return(false) }
+    end
+
+    it "returns a list of all available servers" do
+      Spork::TestFramework.available_test_frameworks.should == []
+      Spork::TestFramework::RSpec.stub!(:available?).and_return(true)
+      Spork::TestFramework.available_test_frameworks.should == [Spork::TestFramework::RSpec]
+    end
+
+    it "returns rspec before cucumber when both are available" do
+      Spork::TestFramework::RSpec.stub!(:available?).and_return(true)
+      Spork::TestFramework::Cucumber.stub!(:available?).and_return(true)
+      Spork::TestFramework.available_test_frameworks.should == [Spork::TestFramework::RSpec, Spork::TestFramework::Cucumber]
+    end
+  end
+
+  describe ".supported_test_frameworks" do
+    it "returns all defined servers" do
+      Spork::TestFramework.supported_test_frameworks.should include(Spork::TestFramework::RSpec)
+      Spork::TestFramework.supported_test_frameworks.should include(Spork::TestFramework::Cucumber)
+    end
+
+    it "returns a list of servers matching a case-insensitive prefix" do
+      Spork::TestFramework.supported_test_frameworks("rspec").should == [Spork::TestFramework::RSpec]
+      Spork::TestFramework.supported_test_frameworks("rs").should == [Spork::TestFramework::RSpec]
+      Spork::TestFramework.supported_test_frameworks("cuc").should == [Spork::TestFramework::Cucumber]
+    end
+  end
+
+  describe ".short_name" do
+    it "returns the name of the framework, without the namespace prefix" do
+      Spork::TestFramework::Cucumber.short_name.should == "Cucumber"
+    end
+  end
+
+  describe ".available?" do
+    it "returns true when the helper_file exists" do
+      FakeFramework.available?.should == false
+      create_helper_file(FakeFramework)
+      FakeFramework.available?.should == true
+    end
+  end
+
+  describe ".bootstrapped?" do
+    it "recognizes if the helper_file has been bootstrapped" do
+      bootstrap_contents = File.read(FakeFramework::BOOTSTRAP_FILE)
+      File.stub!(:read).with(@fake.helper_file).and_return("")
+      @fake.bootstrapped?.should == false
+      File.stub!(:read).with(@fake.helper_file).and_return(bootstrap_contents)
+      @fake.bootstrapped?.should == true
+    end
+  end
+
+  describe ".bootstrap" do
+    it "bootstraps a file" do
+      create_helper_file
+      @fake.bootstrap
+
+      $test_stderr.string.should include("Bootstrapping")
+      $test_stderr.string.should include("Edit")
+      $test_stderr.string.should include("favorite text editor")
+
+      File.read(@fake.helper_file).should include(File.read(FakeFramework::BOOTSTRAP_FILE))
+    end
+  end
+
+  describe ".factory" do
+    it "defaults to use rspec over cucumber" do
+      Spork::TestFramework::RSpec.stub!(:available?).and_return(true)
+      Spork::TestFramework::Cucumber.stub!(:available?).and_return(true)
+      Spork::TestFramework.factory(STDOUT, STDERR).class.should == Spork::TestFramework::RSpec
+    end
+
+    it "defaults to use cucumber when rspec not available" do
+      Spork::TestFramework::RSpec.stub!(:available?).and_return(false)
+      Spork::TestFramework::Cucumber.stub!(:available?).and_return(true)
+      Spork::TestFramework.factory(STDOUT, STDERR).class.should == Spork::TestFramework::Cucumber
+    end
+  end
+end

data/spec/support/fake_framework.rb

@@ -0,0 +1,15 @@
+class FakeFramework < Spork::TestFramework
+  include Spork::TestIOStreams
+
+  attr_accessor :wait_time
+  DEFAULT_PORT = 1000
+
+  def self.helper_file
+    SPEC_TMP_DIR + "/fake/test_helper.rb"
+  end
+
+  def run_tests(argv, input, output)
+    sleep(@wait_time || 0.5)
+    true
+  end
+end

data/spec/support/fake_run_strategy.rb

@@ -0,0 +1,21 @@
+class FakeRunStrategy < Spork::RunStrategy
+  def initialize(*args)
+  end
+
+  def self.available?
+    true
+  end
+
+  def run(argv, stderr, stdout)
+    sleep(@wait_time || 0.5)
+    true
+  end
+
+  def running?
+    false
+  end
+
+  def preload
+    true
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timcharper-spork
 version: !ruby/object:Gem::Version 
-  version: 0.5.10
+  version: 0.6.0
 platform: ruby
 authors: 
 - Tim Harper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-31 00:00:00 -07:00
+date: 2009-09-12 00:00:00 -07:00
 default_executable: spork
 dependencies: []
 
@@ -31,6 +31,7 @@ files:
 - features/diagnostic_mode.feature
 - features/rails_delayed_loading_workarounds.feature
 - features/rspec_rails_integration.feature
+- features/steps/general_steps.rb
 - features/steps/rails_steps.rb
 - features/steps/sandbox_steps.rb
 - features/support/env.rb
@@ -45,21 +46,28 @@ files:
 - lib/spork/custom_io_streams.rb
 - lib/spork/diagnoser.rb
 - lib/spork/forker.rb
+- lib/spork/run_strategy.rb
+- lib/spork/run_strategy/forking.rb
 - lib/spork/runner.rb
 - lib/spork/server.rb
-- lib/spork/server/cucumber.rb
-- lib/spork/server/rspec.rb
+- lib/spork/test_framework.rb
+- lib/spork/test_framework/cucumber.rb
+- lib/spork/test_framework/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
+- spec/spork/run_strategy/forking_spec.rb
 - spec/spork/runner_spec.rb
-- spec/spork/server/cucumber_spec.rb
-- spec/spork/server/rspec_spec.rb
 - spec/spork/server_spec.rb
+- spec/spork/test_framework/cucumber_spec.rb
+- spec/spork/test_framework/rspec_spec.rb
+- spec/spork/test_framework_spec.rb
 - spec/spork_spec.rb
+- spec/support/fake_framework.rb
+- spec/support/fake_run_strategy.rb
 has_rdoc: false
 homepage: http://github.com/timcharper/spork
 post_install_message: 
@@ -94,8 +102,12 @@ test_files:
 - spec/spork/app_framework_spec.rb
 - spec/spork/diagnoser_spec.rb
 - spec/spork/forker_spec.rb
+- spec/spork/run_strategy/forking_spec.rb
 - spec/spork/runner_spec.rb
-- spec/spork/server/cucumber_spec.rb
-- spec/spork/server/rspec_spec.rb
 - spec/spork/server_spec.rb
+- spec/spork/test_framework/cucumber_spec.rb
+- spec/spork/test_framework/rspec_spec.rb
+- spec/spork/test_framework_spec.rb
 - spec/spork_spec.rb
+- spec/support/fake_framework.rb
+- spec/support/fake_run_strategy.rb

data/lib/spork/server/cucumber.rb

@@ -1,35 +0,0 @@
-require 'cucumber'
-
-class Spork::Server::Cucumber < Spork::Server
-  CUCUMBER_PORT = 8990
-  CUCUMBER_HELPER_FILE = File.join(Dir.pwd, "features/support/env.rb")
-
-  class << self
-    def port
-      (ENV['CUCUMBER_DRB'] || CUCUMBER_PORT).to_i
-    end
-
-    def helper_file
-      CUCUMBER_HELPER_FILE
-    end
-
-    # REMOVE WHEN SUPPORT FOR 0.3.95 AND EARLIER IS DROPPED
-    attr_accessor :step_mother
-  end
-
-  # REMOVE WHEN SUPPORT FOR 0.3.95 AND EARLIER IS DROPPED
-  def step_mother
-    self.class.step_mother
-  end
-
-  def run_tests(argv, stderr, stdout)
-    ::Cucumber::Cli::Main.new(argv, stdout, stderr).execute!(step_mother)
-  end
-end
-
-begin
-  Spork::Server::Cucumber.step_mother = ::Cucumber::StepMother.new
-  Spork::Server::Cucumber.step_mother.load_programming_language('rb') if defined?(Spork::Server)
-rescue NoMethodError => pre_cucumber_0_4 # REMOVE WHEN SUPPORT FOR 0.3.95 AND EARLIER IS DROPPED
-  Spork::Server::Cucumber.step_mother = self
-end

data/lib/spork/server/rspec.rb

@@ -1,22 +0,0 @@
-class Spork::Server::RSpec < Spork::Server
-  RSPEC_PORT = 8989
-  RSPEC_HELPER_FILE = File.join(Dir.pwd, "spec/spec_helper.rb")
-  
-  def self.port
-    (ENV['RSPEC_DRB'] ||  RSPEC_PORT).to_i
-  end
-  
-  def self.helper_file
-    RSPEC_HELPER_FILE
-  end
-  
-  def run_tests(argv, stderr, stdout)
-    ::Spec::Runner::CommandLine.run(
-      ::Spec::Runner::OptionParser.parse(
-        argv,
-        stderr,
-        stdout
-      )
-    )
-  end
-end

data/spec/spork/server/cucumber_spec.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Spork::Server::Cucumber do
-  before(:each) do
-    @server = Spork::Server::Cucumber.new
-  end
-  
-  it "uses the CUCUMBER_PORT for it's default port" do
-    @server.port.should == Spork::Server::Cucumber::CUCUMBER_PORT
-  end
-
-  it "uses ENV['CUCUMBER_DRB'] as port if present" do
-    orig = ENV['CUCUMBER_DRB']
-    begin
-      ENV['CUCUMBER_DRB'] = "9000"
-      @server.port.should == 9000
-    ensure
-      ENV['CUCUMBER_DRB'] = orig
-    end
-  end
-  
-  it "uses the CUCUMBER_HELPER_FILE for it's helper_file" do
-    @server.helper_file.should == Spork::Server::Cucumber::CUCUMBER_HELPER_FILE
-  end
-end

data/spec/spork/server/rspec_spec.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Spork::Server::RSpec do
-  before(:each) do
-    @server = Spork::Server::RSpec.new
-  end
-  
-  it "uses the RSPEC_PORT for it's default port" do
-    @server.port.should == Spork::Server::RSpec::RSPEC_PORT
-  end
-
-  it "uses ENV['RSPEC_DRB'] as port if present" do
-    orig = ENV['RSPEC_DRB']
-    begin
-      ENV['RSPEC_DRB'] = "9000"
-      @server.port.should == 9000
-    ensure
-      ENV['RSPEC_DRB'] = orig
-    end
-  end
-  
-  it "uses the RSPEC_HELPER_FILE for it's helper_file" do
-    @server.helper_file.should == Spork::Server::RSpec::RSPEC_HELPER_FILE
-  end
-end