spork 0.9.0.rc8-x86-mswin32

data/lib/spork/server.rb

@@ -0,0 +1,77 @@
+require 'drb/drb'
+require 'rbconfig'
+require 'spork/forker.rb'
+require 'spork/custom_io_streams.rb'
+require 'spork/app_framework.rb'
+
+# An abstract class that is implemented to create a server
+#
+# (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
+  attr_reader :run_strategy
+  include Spork::CustomIOStreams
+  
+  def initialize(options = {})
+    @run_strategy = options[:run_strategy]
+    @port = options[:port]
+  end
+  
+  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.
+  def listen
+    @run_strategy.assert_ready!
+    trap("SIGINT") { sig_int_received }
+    trap("SIGTERM") { abort; exit!(0) }
+    trap("USR2") { abort; restart } if Signal.list.has_key?("USR2")
+    @drb_service = DRb.start_service("druby://127.0.0.1:#{port}", self)
+    Spork.each_run { @drb_service.stop_service } if @run_strategy.class == Spork::RunStrategy::Forking
+    stderr.puts "Spork is ready and listening on #{port}!"
+    stderr.flush
+    DRb.thread.join
+  end
+  
+  attr_accessor :port
+
+  # 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.
+  #                                            # see http://redmine.ruby-lang.org/issues/show/496 to see why localhost:0 is used.
+  #   spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
+  #   spec_server.run(options.argv, $stderr, $stdout)
+  #
+  # When implementing a test server, don't override this method: override run_tests instead.
+  def run(argv, stderr, stdout)
+    puts "Running tests with args #{argv.inspect}..."
+    result = run_strategy.run(argv, stderr, stdout)
+    puts "Done.\n\n"
+    result
+  end
+  
+  def abort
+    run_strategy.abort
+  end
+
+  private
+    def restart
+      stderr.puts "restarting"
+      stderr.flush
+      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 sig_int_received
+      stdout.puts "\n"
+      if run_strategy.running?
+        abort
+        stderr.puts "Running tests stopped.  Press CTRL-C again to stop the server."
+        stderr.flush
+      else
+        exit!(0)
+      end
+    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 #{@framework.helper_file} for the #{@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
+      if not 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 you're 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/test_framework/cucumber.rb

@@ -0,0 +1,38 @@
+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'
+    if ::Cucumber::VERSION >= '0.9.0'
+      # nothing to do nowadays
+    else
+      preload_legacy_cucumbers
+    end
+    super
+  end
+
+  def run_tests(argv, stderr, stdout)
+    if ::Cucumber::VERSION >= '0.9.0'
+      ::Cucumber::Cli::Main.new(argv, stdout, stderr).execute!
+    else
+      ::Cucumber::Cli::Main.new(argv, stdout, stderr).execute!(@step_mother)
+    end
+  end
+
+  private
+  
+  def preload_legacy_cucumbers
+    begin
+      @step_mother = ::Cucumber::Runtime.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
+  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/spec/spec_helper.rb

@@ -0,0 +1,113 @@
+require 'rubygems'
+
+unless $spec_helper_loaded
+  $spec_helper_loaded = true
+
+  $LOAD_PATH.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+  SPEC_TMP_DIR = File.expand_path('tmp', File.dirname(__FILE__))
+  require 'spork'
+  require 'stringio'
+  require 'fileutils'
+  require 'rspec'
+
+  RSpec.configure do |config|
+    config.before(:each) do
+      $test_stdout = StringIO.new
+      $test_stderr = StringIO.new
+      @current_dir = nil
+    end
+  
+    config.after(:each) do
+      FileUtils.rm_rf(SPEC_TMP_DIR) if File.directory?(SPEC_TMP_DIR)
+    
+    end
+  
+    def create_file(filename, contents)
+      FileUtils.mkdir_p(SPEC_TMP_DIR) unless File.directory?(SPEC_TMP_DIR)
+    
+      in_current_dir do
+        FileUtils.mkdir_p(File.dirname(filename))
+        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
+  
+    def current_dir
+      @current_dir ||= SPEC_TMP_DIR
+    end
+    
+    def change_current_dir(sub_path)
+      @current_dir = File.expand_path(sub_path, SPEC_TMP_DIR)
+    end
+    
+    def windows?
+      ENV['OS'] == 'Windows_NT'
+    end
+  end
+
+
+  module RSpec
+    module Matchers
+      class IncludeAStringLike
+        def initialize(substring_or_regex)
+          case substring_or_regex
+          when String
+            @regex = Regexp.new(Regexp.escape(substring_or_regex))
+          when Regexp
+            @regex = substring_or_regex
+          else
+            raise ArgumentError, "don't know what to do with the #{substring_or_regex.class} you provided"
+          end
+        end
+
+        def matches?(list_of_strings)
+          @list_of_strings = list_of_strings
+          @list_of_strings.any? { |s| s =~ @regex }
+        end
+        def failure_message
+          "#{@list_of_strings.inspect} expected to include a string like #{@regex.inspect}"
+        end
+        def negative_failure_message
+          "#{@list_of_strings.inspect} expected to not include a string like #{@regex.inspect}, but did"
+        end
+      end
+
+      def include_a_string_like(substring_or_regex)
+        IncludeAStringLike.new(substring_or_regex)
+      end
+    end
+  end
+
+  module Spork::TestIOStreams
+    def self.included(klass)
+      klass.send(:extend, ::Spork::TestIOStreams::ClassMethods)
+    end
+  
+    def stderr
+      self.class.stderr
+    end
+
+    def stdout
+      self.class.stdout
+    end
+  
+    module ClassMethods
+      def stderr
+        $test_stderr
+      end
+  
+      def stdout
+        $test_stdout
+      end
+    end
+  end
+
+  Dir.glob(File.dirname(__FILE__) + "/support/*.rb").each { |f| require(f) }
+end

data/spec/spork/app_framework/rails_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::AppFramework::Rails do
+  describe ".deprecated_version" do
+    it "detects the current version of rails" do
+      create_file("config/environment.rb", "RAILS_GEM_VERSION = '2.1.0'")
+      in_current_dir do
+        Spork::AppFramework::Rails.new.deprecated_version.should == "2.1.0"
+      end
+      
+      create_file("config/environment.rb", 'RAILS_GEM_VERSION = "2.1.0"')
+      in_current_dir do
+        Spork::AppFramework::Rails.new.deprecated_version.should == "2.1.0"
+      end
+      
+      create_file("config/environment.rb", 'RAILS_GEM_VERSION = "> 2.1.0"')
+      in_current_dir do
+        Spork::AppFramework::Rails.new.deprecated_version.should == "> 2.1.0"
+      end
+    end
+  end
+end

data/spec/spork/app_framework/unknown_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Spork::AppFramework::Unknown do
+  it "requires bootstrapping" do
+    Spork::AppFramework::Unknown.new.bootstrap_required?.should == true
+  end
+  
+  it "has no known entry point" do
+    Spork::AppFramework::Unknown.new.entry_point.should be_nil
+  end
+end
+