bmabey-spork 0.4.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tim Harper
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,72 @@
+= Spork
+
+* http://github.com/timcharper/spork
+
+== SYNOPSIS:
+
+Spork is Tim Harper's implementation of a Drb spec server (similar to the script/spec_server provided by rspec-rails), except rather than using the Rails constant unloading to reload your files, it forks a copy of the server each time you run your specs.  The result?  Spork runs more solid: it doesn't get corrupted over time, and it properly handles modules and any voo-doo meta programming you may have put in your app.
+
+Because Spork uses Kernel.fork, it only works on POSIX systems.  This means Windows users are not invited to this party.  Sorry :(
+
+Spork is still experimental, but is performing solid for us.
+
+== INSTALL:
+
+  [sudo] gem install timcharper-spork --source http://gems.github.com/
+
+alternatively:
+
+  git clone git://github.com/timcharper/spork.git
+  cd spork
+  gem build spork.gemspec
+  sudo gem install spork.gemspec
+
+== Usage
+
+From a terminal, change to your project directory.
+
+Then, bootstrap your spec/spec_helper.rb file.
+
+  spork --bootstrap
+
+Next, edit spec/spec_helper.rb and follow the instructions that were put at the top.
+
+Finally, run spork.  A spec DRb server will be running!
+
+  spork
+
+To get the TextMate RSpec bundle to use spork, go to config->advanced->shell variables, and add TM_RSPEC_OPTS=--drb.
+
+To run from the command line, use spec --drb spec/lib/my_spec.rb
+
+Or, you could add --drb to your spec.opts file.
+
+== Some potential issues and ways to overcome them:
+
+=== ActiveRecord reports "connection has gone away" for the first few specs
+
+Not sure why this happens, but if you simply add a line to re-establish your database connection on each line as follows, the problem goes away:
+
+  Spork.each_run do
+    ActiveRecord::Base.establish_connection # make sure that the db connection is ready.
+  end
+
+=== Couldn't find formatter class Spec::Runner::Formatter::TextMateFormatter Make sure the --require option is specified *before* --format
+
+On one of our projects, many of us using TextMate with spork, only one developer got this error message while the rest of us ran just fine.  I don't know exactly why it happened, but requiring the textmate formatter in the prefork block made it go away, like this:
+
+  Spork.prefork do
+    gem "rspec", "= 1.2.6"
+    require 'spec'
+    ...
+    require 'spec/runner/formatter/text_mate_formatter'
+    ...
+  end
+
+== Kudos to
+
+* Ben Mabey - help with documentation, testing, suggestions, patches, collaborated with Cucumber support.
+* David Chelimsky - for the fine RSpec testing framework, and the original rspec-rails spec_server implementation, which Spork has built upon.
+* Lead Media Partners - just for being an awesome place to work.
+
+Spork (c) 2009 Tim Harper, released under the MIT license

data/assets/bootstrap.rb

@@ -0,0 +1,29 @@
+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.
+#
+
+
+
+

data/bin/spork

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+gem 'test-unit', '1.2.3' if RUBY_VERSION.to_f >= 1.9 # Why do we need this?
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib') unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib')
+
+require 'spork'
+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"))
+  Kernel.exit 1
+end
+
+

data/lib/spork.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+module Spork
+  SPEC_HELPER_FILE = File.join(Dir.pwd, "spec/spec_helper.rb")
+  
+  class << self
+    def prefork(&block)
+      return if @already_preforked
+      @already_preforked = true
+      yield
+    end
+  
+    def each_run(&block)
+      return if @state == :preforking || (@state != :not_using_spork && @already_run)
+      @already_run = true
+      yield
+    end
+  
+    def preforking!
+      @state = :preforking
+    end
+  
+    def running!
+      @state = :running
+    end
+  
+    def state
+      @state ||= :not_using_spork
+    end
+  
+    def exec_prefork(helper_file)
+      preforking!
+      load(helper_file)
+    end
+  
+    def exec_each_run(helper_file)
+      running!
+      load(helper_file)
+    end
+  end
+end

data/lib/spork/runner.rb

@@ -0,0 +1,97 @@
+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 = {}
+      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
+    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
+        @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
+
+    private
+    attr_reader :options 
+
+  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/server/cucumber.rb

@@ -0,0 +1,28 @@
+class Spork::Server::Cucumber < Spork::Server
+  CUCUMBER_PORT = 8990
+  CUCUMBER_HELPER_FILE = File.join(Dir.pwd, "features/support/env.rb")
+  
+  class << self
+    def port
+      CUCUMBER_PORT
+    end
+    
+    def helper_file
+      CUCUMBER_HELPER_FILE
+    end
+
+    attr_accessor :step_mother
+  end
+  
+  def step_mother
+    self.class.step_mother
+  end
+  
+  def run_tests(argv, stderr, stdout)
+    require 'cucumber/cli/main'
+    ::Cucumber::Cli::Main.step_mother = step_mother
+    ::Cucumber::Cli::Main.new(argv, stdout, stderr).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/spec/spec_helper.rb

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

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

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: bmabey-spork
+version: !ruby/object:Gem::Version 
+  version: 0.4.4
+platform: ruby
+authors: 
+- Tim Harper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-30 00:00:00 -07:00
+default_executable: spork
+dependencies: []
+
+description: A forking Drb spec server
+email: 
+- timcharper+spork@gmail.com
+executables: 
+- spork
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- assets/bootstrap.rb
+- lib/spork.rb
+- lib/spork/runner.rb
+- 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: false
+homepage: http://github.com/timcharper/spork
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: spork
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+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