nimboids-spork 0.8.99

data/features/support/background_job.rb

@@ -0,0 +1,63 @@
+class BackgroundJob
+  attr_reader :stdin, :stdout, :stderr, :pid
+  def initialize(pid, stdin, stdout, stderr)
+    @pid, @stdin, @stdout, @stderr = pid, stdin, stdout, stderr
+    ObjectSpace.define_finalizer(self) { kill }
+  end
+
+  def self.run(command)
+    command = sanitize_params(command) if command.is_a?(Array)
+    child_stdin, parent_stdin = IO::pipe
+    parent_stdout, child_stdout = IO::pipe
+    parent_stderr, child_stderr = IO::pipe
+
+    pid = Kernel.fork do
+      [parent_stdin, parent_stdout, parent_stderr].each { |io| io.close }
+
+      STDIN.reopen(child_stdin)
+      STDOUT.reopen(child_stdout)
+      STDERR.reopen(child_stderr)
+
+      [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+
+      exec command
+    end
+
+    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+    parent_stdin.sync = true
+
+    new(pid, parent_stdin, parent_stdout, parent_stderr)
+  end
+
+  def self.sanitize_params(params)
+    params.map { |p| p.gsub(' ', '\ ') }.join(" ")
+  end
+
+  def kill(signal = 'TERM')
+    if running?
+      Process.kill(Signal.list[signal], @pid)
+      true
+    end
+  end
+
+  def interrupt
+    kill('INT')
+  end
+
+  def running?
+    return false unless @pid
+    Process.getpgid(@pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  def wait(timeout = 1000)
+    Timeout.timeout(timeout) do
+      Process.wait(@pid)
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+end

data/features/support/bundler_helpers.rb

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

data/features/support/env.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'pathname'
+require 'fileutils'
+require 'forwardable'
+require 'tempfile'
+require 'rspec/expectations'
+require 'timeout'
+
+require(File.dirname(__FILE__) + '/background_job.rb')
+
+SPORK_ROOT    = Pathname.new(File.expand_path('../../', File.dirname(__FILE__)))
+class SporkWorld
+  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  BINARY        = SPORK_ROOT + 'bin/spork'
+  SANDBOX_DIR   = SPORK_ROOT + "tmp/sandbox"
+  GEMFILES_ROOT = SPORK_ROOT + "features/gemfiles"
+  SPORK_LIBDIR  = SPORK_ROOT + "lib"
+  
+  extend Forwardable
+  def_delegators SporkWorld, :sandbox_dir, :spork_lib_dir
+
+  def spork_lib_dir
+    @spork_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+
+  def initialize
+    @current_dir = SANDBOX_DIR
+    @background_jobs = []
+  end
+
+  private
+  attr_reader :last_exit_status, :last_stderr, :last_stdout, :background_jobs
+  def last_stderr
+    return @last_stderr if @last_stderr
+    if @background_job
+      @last_stderr = @background_job.stderr.read
+    end
+  end
+
+
+  def last_stdout
+    return @last_stdout if @last_stdout
+    if @background_job
+      @last_stdout = @background_job.stdout.read
+    end
+  end
+
+  def create_file(file_name, file_content)
+    file_content.gsub!("SPORK_LIB", "'#{spork_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
+    in_current_dir do
+      FileUtils.mkdir_p(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+
+  def run(command)
+    stderr_file = Tempfile.new('spork')
+    stderr_file.close
+    in_current_dir do
+      @last_stdout = `env RUBYOPT= bundle exec #{command} 2> #{stderr_file.path}`
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+  def run_in_background(command)
+    in_current_dir do
+      @background_job = BackgroundJob.run("env RUBYOPT= bundle exec " +  command)
+    end
+    @background_jobs << @background_job
+    @background_job
+  end
+
+  def terminate_background_jobs
+    if @background_jobs
+      @background_jobs.each do |background_job|
+        background_job.kill
+      end
+    end
+    @background_jobs.clear
+    @background_job = nil
+  end
+end
+
+require(SPORK_ROOT + "features/support/bundler_helpers.rb")
+BundlerHelpers.set_gemfile(ENV["GEMFILE"])
+
+
+World do
+  SporkWorld.new
+end
+
+Before do
+  FileUtils.rm_rf SporkWorld::SANDBOX_DIR
+  FileUtils.mkdir_p SporkWorld::SANDBOX_DIR
+end
+
+After do
+  # FileUtils.rm_rf SporkWorld::SANDBOX_DIR
+  terminate_background_jobs
+end

data/features/unknown_app_framework.feature

@@ -0,0 +1,42 @@
+Feature: Unknown app frameworks
+  To increase to usefulness of Spork 
+  Spork will work with unknown (or no) application frameworks
+
+  Scenario: Unsporked spec_helper
+  
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spec'
+      """
+    When I run spork
+    Then the error output should contain "Using RSpec"
+    Then the error output should match /You must bootstrap .+spec\/spec_helper\.rb to continue/
+  
+  Scenario: Sporked spec_helper
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+      
+      Spork.prefork do
+        require 'spec'
+      end
+      
+      Spork.each_run do
+        $each_run
+      end
+      """
+    And a file named "spec/did_it_work_spec.rb" with:
+      """
+      describe "Did it work?" do
+        it "checks to see if all worked" do
+          Spork.state.should == :using_spork
+          puts "Specs successfully run within spork"
+        end
+      end
+      """
+    When I fire up a spork instance with "spork rspec"
+    And I run spec --drb spec/did_it_work_spec.rb 
+    Then the output should contain "Specs successfully run within spork"
+  

data/lib/spork.rb

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

data/lib/spork/app_framework.rb

@@ -0,0 +1,80 @@
+class Spork::AppFramework
+  # A hash of procs where the key is the class name, and the proc takes no arguments and returns true if it detects that said application framework is being used in the project.
+  # 
+  # The key :Rails maps to Spork::AppFramework::Rails
+  #
+  # This is used to reduce the amount of code needed to be loaded - only the detected application framework's support code is loaded.
+  SUPPORTED_FRAMEWORKS = {
+    :Padrino => lambda {
+      File.exist?("config/boot.rb") && File.read("config/boot.rb").include?('PADRINO')
+    },
+    :Rails => lambda {
+      File.exist?("config/environment.rb") && (
+        File.read("config/environment.rb").include?('RAILS_GEM_VERSION') ||
+        (File.exist?("config/application.rb") && File.read("config/application.rb").include?("Rails::Application"))
+      )
+    }
+  } unless defined? SUPPORTED_FRAMEWORKS
+  
+  def self.setup_autoload
+    ([:Unknown] + SUPPORTED_FRAMEWORKS.keys).each do |name|
+      autoload name, File.join(File.dirname(__FILE__), "app_framework", name.to_s.downcase)
+    end
+  end
+  
+  # Iterates through all SUPPORTED_FRAMEWORKS and returns the symbolic name of the project application framework detected.  Otherwise, returns :Unknown
+  def self.detect_framework_name
+    SUPPORTED_FRAMEWORKS.each do |key, value|
+      return key if value.call
+    end
+    :Unknown
+  end
+  
+  # Same as detect_framework_name, but returns an instance of the specific AppFramework class.
+  def self.detect_framework
+    name = detect_framework_name
+    self[name]
+  end
+  
+  # Initializes, stores, and returns a singleton instance of the named AppFramework.
+  #
+  # == Parameters
+  #
+  # # +name+ - A symbolic name of a AppFramework subclass
+  #
+  # == Example
+  #
+  #   Spork::AppFramework[:Rails]
+  def self.[](name)
+    instances[name] ||= const_get(name).new
+  end
+  
+  def self.short_name
+    name.gsub('Spork::AppFramework::', '')
+  end
+  
+  # If there is some stuff out of the box that the Spork can do to speed up tests without the test helper file being bootstrapped, this should return false.
+  def bootstrap_required?
+    entry_point.nil?
+  end
+  
+  # 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 NotImplementedError
+  end
+  
+  def preload(&block)
+    yield
+  end
+  
+  def short_name
+    self.class.short_name
+  end
+  
+  protected
+    def self.instances
+      @instances ||= {}
+    end
+end
+
+Spork::AppFramework.setup_autoload