timcharper-spork 0.3.1 → 0.4.0

data/bin/spork

@@ -10,6 +10,8 @@ require 'spork/runner'
 begin
   success = Spork::Runner.run(ARGV, STDOUT, STDERR)
   Kernel.exit(success ? 0 : 1)
+rescue SystemExit => e
+  Kernel.exit(e.status)
 rescue Exception => e
   STDERR.puts("#{e.message} (#{e.class})")
   STDERR.puts(e.backtrace.join("\n"))

data/lib/spork/runner.rb

@@ -1,50 +1,86 @@
 require 'optparse'
+require 'spork/server'
 
 module Spork
   class Runner
-
+    attr_reader :server
+    
     def self.run(args, output, error)
       self.new(args, output, error).run
     end
-
+    
     def initialize(args, output, error)
+      raise ArgumentError, "expected array of args" unless args.is_a?(Array)
       @output = output
       @error = error
       @options = {}
-      parser = OptionParser.new
-      parser.on("-d", "--daemon")     {|ignore| @options[:daemon] = true }
-      parser.on("-b", "--bootstrap")  {|ignore| @options[:bootstrap] = true }
-      parser.on("-p", "--pid PIDFILE"){|pid|    @options[:pid]    = pid  }
-      parser.parse!(args)
-    end
-
-
-    def run
-      ENV["DRB"] = 'true'
-      ENV["RAILS_ENV"] ||= 'test' if Spork.using_rails?
-
-      unless File.exist?(Spork::SPEC_HELPER_FILE)
-        @output.puts  <<-USEFUL_ERROR
-        Bummer!
-
-        I can't find the file spec/spec_helper.rb, which I need in order to run.
-
-        Are you running me from a project directory that has rspec set up?
-        USEFUL_ERROR
-        return false
+      opt = OptionParser.new
+      opt.banner = "Usage: spork [test framework name] [options]\n\n"
+      
+      opt.separator "Options:"
+      opt.on("-b", "--bootstrap")  {|ignore| @options[:bootstrap] = true }
+      opt.on("-h", "--help")  {|ignore| @options[:help] = true }
+      non_option_args = args.select { |arg| ! args[0].match(/^-/) }
+      @options[:server_matcher] = non_option_args[0]
+      opt.parse!(args)
+      
+      if @options[:help]
+        @output.puts opt
+        @output.puts
+        @output.puts supported_servers_text
+        exit(0)
       end
-
-
-      return Spork.bootstrap if options[:bootstrap]
-
-      require 'spork/spec_server'
-      return(false) unless Spork.preload
-
-      if options[:daemon]
-        ::Spork::SpecServer.daemonize(options[:pid])
+    end
+    
+    def supported_servers_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 "\nLegend: ( ) - not detected in project   (*) - detected\n"
+      text.string
+    end
+    
+    def find_server
+      if options[:server_matcher]
+        @server = Spork::Server.supported_servers(options[:server_matcher]).first
+        unless @server
+          @output.puts <<-ERROR
+#{options[:server_matcher].inspect} didn't match a supported test framework.
+
+#{supported_servers_text}
+          ERROR
+          return
+        end
+        
+        unless @server.available?
+          @output.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
-        ::Spork::SpecServer.run
+        @server = Spork::Server.available_servers.first
+        if @server.nil?
+          @output.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
+    end
+    
+    def run
+      return false unless find_server
+      ENV["DRB"] = 'true'
+      ENV["RAILS_ENV"] ||= 'test' if server.using_rails?
+      @output.puts "Using #{server.server_name}"
+      return server.bootstrap if options[:bootstrap]
+      return(false) unless server.preload
+      server.run
       return true
     end
 

data/lib/spork/server/cucumber.rb

@@ -0,0 +1,24 @@
+class Spork::Server::Cucumber < Spork::Server
+  CUCUMBER_PORT = 8990
+  CUCUMBER_HELPER_FILE = File.join(Dir.pwd, "features/support/env.rb")
+  
+  def self.port
+    CUCUMBER_PORT
+  end
+  
+  def self.helper_file
+    CUCUMBER_HELPER_FILE
+  end
+  
+  def self.step_mother=(value)
+    @step_mother = value
+  end
+  
+  def run_tests(argv, stderr, stdout)
+    require 'cucumber/cli/main'
+    ::Cucumber::Cli::Main.step_mother = @step_mother
+    ::Cucumber::Cli::Main.new(argv, stderr, stdout).execute!(@step_mother)
+  end
+end
+
+Spork::Server::Cucumber.step_mother = self

data/lib/spork/server/rspec.rb

@@ -0,0 +1,22 @@
+class Spork::Server::RSpec < Spork::Server
+  RSPEC_PORT = 8989
+  RSPEC_HELPER_FILE = File.join(Dir.pwd, "spec/spec_helper.rb")
+  
+  def self.port
+    RSPEC_PORT
+  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/lib/spork/server.rb

@@ -0,0 +1,159 @@
+require 'drb/drb'
+require 'rbconfig'
+
+# This is 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"
+  
+  def self.port
+    raise NotImplemented
+  end
+  
+  def self.helper_file
+    raise NotImplemented
+  end
+  
+  def self.server_name
+    self.name.gsub('Spork::Server::', '')
+  end
+  
+  def self.inherited(subclass)
+    @@supported_servers << subclass
+  end
+  
+  def self.available_servers
+    supported_servers.select { |s| s.available? }
+  end
+  
+  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
+  
+  def self.available?
+    File.exist?(helper_file)
+  end
+  
+  def self.load_preference_index
+    LOAD_PREFERENCE.index(server_name) || LOAD_PREFERENCE.length
+  end
+  
+  def self.using_rails?
+    File.exist?("config/environment.rb")
+  end
+  
+  def self.bootstrapped?
+    File.read(helper_file).include?("Spork.prefork")
+  end
+  
+  def self.bootstrap
+    if bootstrapped?
+      puts "Already bootstrapped!"
+      return
+    end
+    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
+    
+    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
+  end
+  
+  def listen
+    trap("SIGINT") { sig_int_received }
+    trap("SIGTERM") { abort; exit!(0) }
+    trap("USR2") { abort; restart } if Signal.list.has_key?("USR2")
+    DRb.start_service("druby://127.0.0.1:#{port}", self)
+    puts "Spork is ready and listening on #{port}!"
+    DRb.thread.join
+  end
+  
+  def port
+    self.class.port
+  end
+  
+  def helper_file
+    self.class.helper_file
+  end
+  
+  def run(argv, stderr, stdout)
+    return false if running?
+    $stdout = stdout
+    $stderr = stderr
+    @child_pid = Kernel.fork do
+      Spork.exec_each_run(helper_file)
+      run_tests(argv, stderr, stdout)
+    end
+    Process.wait(@child_pid)
+    @child_pid = nil
+    true
+  end
+  
+  def running?
+    !! @child_pid
+  end
+  
+  private
+    def self.preload
+      if bootstrapped?
+        puts "Loading Spork.prefork block..."
+        Spork.exec_prefork(helper_file)
+      else
+        puts "#{helper_file} has not been sporked.  Run spork --bootstrap to do so."
+        # are we in a rails app?
+        if using_rails?
+          puts "Preloading Rails environment"
+          require "config/environment.rb"
+        else
+          puts "There's nothing I can really do for you.  Bailing."
+          return false
+        end
+      end
+      true
+    end
+    
+    def run_tests(argv, input, output)
+      raise NotImplemented
+    end
+    
+    def restart
+      puts "restarting"
+      config       = ::Config::CONFIG
+      ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
+      command_line = [ruby, $0, ARGV].flatten.join(' ')
+      exec(command_line)
+    end
+    
+    def abort
+      if running?
+        Process.kill(Signal.list['TERM'], @child_pid)
+        true
+      end
+    end
+    
+    def sig_int_received
+      if running?
+        abort
+        puts "Running specs stopped.  Press CTRL-C again to stop the server."
+      else
+        exit!(0)
+      end
+    end
+end
+
+Dir[File.dirname(__FILE__) + "/server/*.rb"].each { |file| require file }

data/lib/spork.rb

@@ -2,67 +2,39 @@ $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.i
 module Spork
   SPEC_HELPER_FILE = File.join(Dir.pwd, "spec/spec_helper.rb")
   
-  def self.prefork(&block)
-    return if @already_preforked
-    @already_preforked = true
-    yield
-  end
-  
-  def self.each_run(&block)
-    return if @state == :preforking || (@state != :not_using_spork && @already_run)
-    @already_run = true
-    yield
-  end
-  
-  def self.preforking!
-    @state = :preforking
-  end
+  class << self
+    def prefork(&block)
+      return if @already_preforked
+      @already_preforked = true
+      yield
+    end
   
-  def self.running!
-    @state = :running
-  end
+    def each_run(&block)
+      return if @state == :preforking || (@state != :not_using_spork && @already_run)
+      @already_run = true
+      yield
+    end
   
-  def self.state
-    @state ||= :not_using_spork
-  end
+    def preforking!
+      @state = :preforking
+    end
   
-  def self.using_rails?
-    File.exist?("config/environment.rb")
-  end
+    def running!
+      @state = :running
+    end
   
-  def self.using_prefork?
-    File.read(SPEC_HELPER_FILE).include?("Spork.prefork")
-  end
+    def state
+      @state ||= :not_using_spork
+    end
   
-  def self.bootstrap
-    puts "Bootstrapping #{SPEC_HELPER_FILE}"
-    contents = File.read(SPEC_HELPER_FILE)
-    bootstrap_code = File.read(File.dirname(__FILE__) + "/../assets/bootstrap.rb")
-    File.open(SPEC_HELPER_FILE, "wb") do |f|
-      f.puts bootstrap_code
-      f.puts contents
+    def exec_prefork(helper_file)
+      preforking!
+      load(helper_file)
     end
-    
-    puts "Done. Edit #{SPEC_HELPER_FILE} now with your favorite text editor and follow the instructions."
-    true
-  end
   
-  def self.preload
-    if using_prefork?
-      puts "Loading Spork.prefork block..."
-      Spork.preforking!
-      load SPEC_HELPER_FILE
-    else
-      puts "spec_helper.rb is has not been sporked.  Run spork --bootstrap to do so."
-      # are we in a rails app?
-      if using_rails?
-        puts "Preloading Rails environment"
-        require "config/environment.rb"
-      else
-        puts "There's nothing I can really do for you.  Bailing."
-        return false
-      end
+    def exec_each_run(helper_file)
+      running!
+      load(helper_file)
     end
-    true
   end
 end

data/spec/spec_helper.rb

@@ -1,9 +1,49 @@
+require 'rubygems'
+require 'spork'
+
+Spork.prefork do
+  # Loading more in this block will cause your specs to run faster. However, 
+  # if you change any configuration or code from libraries loaded here, you'll
+  # need to restart spork for it take effect.
+  
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+  
+end
+
+# --- Instructions ---
+# - Sort through your spec_helper file. Place as much environment loading 
+#   code that you don't normally modify during development in the 
+#   Spork.prefork block.
+# - Place the rest under Spork.each_run block
+# - Any code that is left outside of the blocks will be ran during preforking
+#   and during each_run!
+# - These instructions should self-destruct in 10 seconds.  If they don't,
+#   feel free to delete them.
+#
+
+
+
+
+require 'rubygems'
 require 'spec'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+SPEC_TMP_DIR = File.dirname(__FILE__) + "/tmp"
 require 'spork'
+require 'spork/runner.rb'
+require 'spork/server.rb'
+require 'stringio'
 
 Spec::Runner.configure do |config|
+  config.before(:each) do
+    $test_stdout = StringIO.new
+  end
   
+  config.after(:each) do
+    FileUtils.rm_rf(SPEC_TMP_DIR)
+  end
 end

data/spec/spork/runner_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spork::Runner do
+  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
+  end
+  
+  it "shows an error message if no matching server was found" do
+    Spork::Runner.new(["argle_bargle"], @out, @err).run.should == false
+    @out.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
+  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)
+    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)
+    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)
+    Spork::Runner.new(['rspec'], @out, @err).run
+    @out.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::Runner.new(['rspec'], @out, @err).supported_servers_text.should == <<-EOF
+Supported test frameworks:
+( ) Cucumber
+(*) RSpec
+
+Legend: ( ) - not detected in project   (*) - detected
+    EOF
+  end
+end

data/spec/spork/server/rspec_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::Server::RSpec do
+  before(:each) do
+    @adapter = Spork::Adapter::RSpec.new
+  end
+  
+  it "uses the RSPEC_PORT for it's port" do
+    @adapter.port.should == Spork::Adapter::RSpec::RSPEC_PORT
+  end
+end

data/spec/spork/server_spec.rb

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class FakeServer < Spork::Server
+  attr_accessor :wait_time
+  def self.helper_file
+    SPEC_TMP_DIR + "/fake/test_helper.rb"
+  end
+  
+  def self.port
+    1000
+  end
+  
+  def self.puts(string)
+    $test_stdout.puts(string)
+  end
+  
+  def puts(string)
+    $test_stdout.puts(string)
+  end
+  
+  def run_tests(argv, input, output)
+    sleep(@wait_time || 0.5)
+  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
+      FileUtils.mkdir_p(File.dirname(FakeServer.helper_file))
+      FileUtils.touch(FakeServer.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_stdout.string.should include("Bootstrapping")
+      $test_stdout.string.should include("Edit")
+      $test_stdout.string.should include("favorite text editor")
+    
+      File.read(FakeServer.helper_file).should include(File.read(FakeServer::BOOTSTRAP_FILE))
+    end
+  
+    it "prevents you from running specs twice in parallel" do
+      create_helper_file
+      @fake.wait_time = 0.25
+      first_run = Thread.new { @fake.run("test", STDOUT, STDIN).should == true }
+      sleep(0.05)
+      @fake.run("test", STDOUT, STDIN).should == false
+    
+      # 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
+  end
+end

data/spec/spork_spec.rb

@@ -1,7 +1,44 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
+Spork.class_eval do
+  def self.reset!
+    @state = nil
+    @already_run = nil
+    @already_preforked = nil
+  end
+end
+
 describe Spork do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+  before(:each) do
+    Spork.reset!
+  end
+  
+  def spec_helper_simulator
+    ran = []
+    Spork.prefork do
+      ran << :prefork
+    end
+    
+    Spork.each_run do
+      ran << :each_run
+    end
+    ran
+  end
+  
+  it "only runs the preload block when preforking" do
+    ran = []
+    Spork.preforking!
+    spec_helper_simulator.should == [:prefork]
+  end
+  
+  it "only runs the each_run block when running" do
+    Spork.preforking!
+    spec_helper_simulator
+    Spork.running!
+    spec_helper_simulator.should == [:each_run]
+  end
+  
+  it "runs both blocks when Spork not activated" do
+    spec_helper_simulator.should == [:prefork, :each_run]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timcharper-spork
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tim Harper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 -07:00
+date: 2009-05-29 00:00:00 -07:00
 default_executable: spork
 dependencies: []
 
@@ -23,13 +23,19 @@ extensions: []
 extra_rdoc_files: 
 - README.rdoc
 files: 
-- History.txt
 - README.rdoc
 - assets/bootstrap.rb
 - lib/spork.rb
 - lib/spork/runner.rb
-- lib/spork/spec_server.rb
-has_rdoc: false
+- lib/spork/server.rb
+- lib/spork/server/cucumber.rb
+- lib/spork/server/rspec.rb
+- spec/spec_helper.rb
+- spec/spork/runner_spec.rb
+- spec/spork/server/rspec_spec.rb
+- spec/spork/server_spec.rb
+- spec/spork_spec.rb
+has_rdoc: true
 homepage: http://github.com/timcharper/spork
 post_install_message: 
 rdoc_options: 
@@ -54,8 +60,11 @@ requirements: []
 rubyforge_project: spork
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 3
-summary: spork 0.3
+specification_version: 2
+summary: spork
 test_files: 
 - spec/spec_helper.rb
+- spec/spork/runner_spec.rb
+- spec/spork/server/rspec_spec.rb
+- spec/spork/server_spec.rb
 - spec/spork_spec.rb

data/History.txt

@@ -1,10 +0,0 @@
-== 0.3.x (Git)
- === New Features
-
- === Bugfixes
-
-== 0.3.1 2009-05-25
-  * Extracted bin logic into Runner file, improved requiring and load path setup, and cleaned up file organization. (Ben Mabey)
-
-== 0.3.0 2009-05
-  * Initial release with SpecServer, Bootstraper, and basic option parsing. (Tim Harper)

data/lib/spork/spec_server.rb

@@ -1,58 +0,0 @@
-require 'drb/drb'
-require 'rbconfig'
-
-# This is based off of spec_server.rb from rspec-rails (David Chelimsky), which was based on Florian Weber's TDDMate
-class Spork::SpecServer
-  DRB_PORT = 8989
-  def self.restart_test_server
-    puts "restarting"
-    config       = ::Config::CONFIG
-    ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
-    command_line = [ruby, $0, ARGV].flatten.join(' ')
-    exec(command_line)
-  end
-
-  def self.daemonize(pid_file = nil)
-    return yield if $DEBUG
-    pid = Process.fork{
-      Process.setsid
-      trap("SIGINT"){ exit! 0 }
-      trap("SIGTERM"){ exit! 0 }
-      trap("SIGHUP"){ restart_test_server }
-      File.open("/dev/null"){|f|
-        STDERR.reopen f
-        STDIN.reopen  f
-        STDOUT.reopen f
-      }
-      run
-    }
-    puts "spec_server launched (PID: %d)" % pid
-    File.open(pid_file,"w"){|f| f.puts pid } if pid_file
-    exit! 0
-  end
-  
-  def self.run
-    trap("USR2") { ::Spork::SpecServer.restart_test_server } if Signal.list.has_key?("USR2")
-    DRb.start_service("druby://127.0.0.1:#{DRB_PORT}", ::Spork::SpecServer.new)
-    puts "Spork is ready and listening on #{DRB_PORT}!"
-    DRb.thread.join
-  end
-  
-  def run(argv, stderr, stdout)
-    $stdout = stdout
-    $stderr = stderr
-    child_pid = Kernel.fork do
-      Spork.running!
-      load ::Spork::SPEC_HELPER_FILE
-    
-      ::Spec::Runner::CommandLine.run(
-        ::Spec::Runner::OptionParser.parse(
-          argv,
-          $stderr,
-          $stdout
-        )
-      )
-    end
-    Process.wait(child_pid)
-  end
-end