spork 0.4.4 → 0.5.1

data/features/diagnostic_mode.feature

@@ -0,0 +1,37 @@
+Feature: Diagnostic Mode
+  To help a developer quickly pinpoint why files are being loaded
+  Spork provides a diagnostic mode
+  That provides a list of which project files were loaded during prefork, and who loaded them.
+
+  Scenario: Running spork --diagnose
+    Given I am in the directory "test_project"
+    And a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+
+      Spork.prefork do
+        require 'lib/awesome.rb'
+        require '../external_dependency/super_duper.rb'
+      end
+
+      Spork.each_run do
+        puts "I'm loading the stuff just for this run..."
+      end
+      """
+    And a file named "lib/awesome.rb" with:
+      """
+      class Awesome
+      end
+      """
+    And a file named "../external_dependency/super_duper.rb" with:
+      """
+      class Awesome
+      end
+      """
+    When I run spork --diagnose
+    Then the output should contain "lib/awesome.rb"
+    And the output should contain "spec/spec_helper.rb:5"
+    And the output should not contain "super_duper.rb"
+    And the output should not contain "diagnose.rb"
+     

data/features/rails_integration.feature

@@ -0,0 +1,81 @@
+Feature: Rails Integration
+  To get a developer up and running quickly
+  Spork automatically integrates with rails
+  Providing default hooks and behaviors
+
+  Background: Rails App with RSpec and Spork
+
+    Given I am in a fresh rails project named "test_rails_project"
+    And a file named "spec/spec_helper.rb" with:
+      """
+      require 'rubygems'
+      require 'spork'
+      require 'spec'
+
+      Spork.prefork do
+        $run_phase = :prefork
+        require File.dirname(__FILE__) + '/../config/environment.rb'
+      end
+
+      Spork.each_run do
+        $run_phase = :each_run
+        puts "I'm loading the stuff just for this run..."
+      end
+      
+      class ActiveRecord::Base
+        class << self
+          def establish_connection
+            ($loaded_stuff ||= []) << 'establish_connection'
+            puts "Database connection was automatically re-established!"
+          end
+        end
+      end
+      """
+    And a file named "app/models/user.rb" with:
+      """
+      class User < ActiveRecord::Base
+        ($loaded_stuff ||= []) << 'User'
+      end
+      """
+    And a file named "app/helpers/application_helper.rb" with:
+      """
+      module ApplicationHelper
+        ($loaded_stuff ||= []) << 'ApplicationHelper'
+      end
+      """
+    And a file named "app/models/user_observer.rb" with:
+      """
+      class UserObserver < ActiveRecord::Observer
+        ($loaded_stuff ||= []) << 'UserObserver'
+      end
+      """
+    And the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
+      """
+        config.active_record.observers = :user_observer
+      """
+    And a file named "spec/models/user_spec.rb" with:
+      """
+      describe User do
+        it "does absoluately nothing" do
+          Spork.state.should == :using_spork
+          $loaded_stuff.should include('establish_connection')
+          $loaded_stuff.should include('User')
+          $loaded_stuff.should include('UserObserver')
+          $loaded_stuff.should include('ApplicationHelper')
+          puts "Specs successfully run within spork, and all initialization files were loaded"
+        end
+      end
+      """
+  Scenario: Analyzing files were preloaded
+    When I run spork --diagnose
+    Then the output should not contain "user_observer.rb"
+    Then the output should not contain "user.rb"
+    Then the output should not contain "app/controllers/application.rb"
+    Then the output should not contain "app/controllers/application_controller.rb"
+    Then the output should not contain "app/controllers/application_helper.rb"
+  
+  Scenario: Running spork with a rails app and observers
+  
+    When I fire up a spork instance with "spork rspec"
+    And I run spec --drb spec/models/user_spec.rb 
+    Then the output should contain "Specs successfully run within spork, and all initialization files were loaded"

data/features/steps/rails_steps.rb

@@ -0,0 +1,7 @@
+Given /^I am in a fresh rails project named "(.+)"$/ do |folder_name|
+  @current_dir = SporkWorld::SANDBOX_DIR
+  version_argument = ENV['RAILS_VERSION'] ? "_#{ENV['RAILS_VERSION']}_" : nil
+  # run("#{SporkWorld::RUBY_BINARY} #{%x{which rails}.chomp} #{folder_name}")
+  run([SporkWorld::RUBY_BINARY, %x{which rails}.chomp, version_argument, folder_name].compact * " ")
+  @current_dir = File.join(File.join(SporkWorld::SANDBOX_DIR, folder_name))
+end

data/features/steps/sandbox_steps.rb

@@ -0,0 +1,78 @@
+Given /^I am in the directory "(.*)"$/ do |sandbox_dir_relative_path|
+  path = File.join(SporkWorld::SANDBOX_DIR, sandbox_dir_relative_path)
+  FileUtils.mkdir_p(path)
+  @current_dir = File.join(path)
+end
+
+Given /^a file named "([^\"]*)"$/ do |file_name|
+  create_file(file_name, '')
+end
+
+Given /^a file named "([^\"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+# the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
+Given /^the following code appears in "([^\"]*)" after \/([^\\\/]*)\/:$/ do |file_name, regex, content|
+  # require 'ruby-debug'; Debugger.start; Debugger.start_control; debugger
+  
+  regex = Regexp.new(regex)
+  in_current_dir do
+    content_lines = File.read(file_name).split("\n")
+    0.upto(content_lines.length - 1) do |line_index|
+      if regex.match(content_lines[line_index])
+        puts "found: #{content_lines[line_index]}"
+        content_lines.insert(line_index + 1, content)
+        break
+      end
+    end
+    File.open(file_name, 'wb') { |f| f << (content_lines * "\n") }
+  end
+end
+
+When /^I run (spork|spec)($| .*$)/ do |command, spork_opts|
+  if command == 'spork'
+    command = SporkWorld::BINARY
+  else
+    command = %x{which #{command}}.chomp
+  end
+  run "#{SporkWorld::RUBY_BINARY} #{command} #{spork_opts}"
+end
+
+When /^I fire up a spork instance with "spork(.*)"$/ do |spork_opts|
+  run_in_background "#{SporkWorld::RUBY_BINARY} #{SporkWorld::BINARY} #{spork_opts}"
+  output = ""
+  begin
+    status = Timeout::timeout(15) do
+      # Something that should be interrupted if it takes too much time...
+      while line = @bg_stderr.gets
+        output << line
+        puts line
+        break if line.include?("Spork is ready and listening")
+      end
+    end
+  rescue Timeout::Error
+    puts "I can't seem to launch Spork properly.  Output was:\n#{output}"
+    true.should == false
+  end
+end
+
+Then /^the output should contain$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^the output should contain "(.+)"$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^the output should not contain$/ do |text|
+  last_stdout.should_not include(text)
+end
+
+Then /^the output should not contain "(.+)"$/ do |text|
+  last_stdout.should_not include(text)
+end
+
+Then /^the output should be$/ do |text|
+  last_stdout.should == text
+end

data/features/support/env.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'fileutils'
+require 'forwardable'
+require 'tempfile'
+require 'spec/expectations'
+require 'timeout'
+
+class SporkWorld
+  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/spork')
+  SANDBOX_DIR   = File.expand_path(File.join(File.dirname(__FILE__), '../../tmp/sandbox'))
+  
+  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 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 = `#{command} 2> #{stderr_file.path}`
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+  def run_in_background(command)
+    child_stdin, parent_stdin = IO::pipe
+    parent_stdout, child_stdout = IO::pipe
+    parent_stderr, child_stderr = IO::pipe
+    
+    background_jobs << Kernel.fork do
+      # grandchild
+      [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 }
+
+      in_current_dir do
+        exec command
+      end
+    end
+    
+    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+    parent_stdin.sync = true
+    
+    @bg_stdin, @bg_stdout, @bg_stderr = [parent_stdin, parent_stdout, parent_stderr]
+  end
+
+  def terminate_background_jobs
+    if @background_jobs
+      @background_jobs.each do |pid|
+        Process.kill(Signal.list['TERM'], pid)
+      end
+    end
+  end
+
+end
+
+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/lib/spork.rb

@@ -1,46 +1,51 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 module Spork
   class << self
-    def already_preforked
-      @already_preforked ||= []
+    def already_ran
+      @already_ran ||= []
     end
     
-    def already_run
-      @already_run ||= []
+    def each_run_procs
+      @each_run_procs ||= []
     end
     
     def prefork(&block)
-      return if already_preforked.include?(expanded_caller(caller.first))
-      already_preforked << expanded_caller(caller.first)
+      return if already_ran?(caller.first)
       yield
     end
-  
+    
     def each_run(&block)
-      return if @state == :preforking || (@state != :not_using_spork && already_run.include?(expanded_caller(caller.first)))
-      already_run << expanded_caller(caller.first)
-      yield
+      return if already_ran?(caller.first)
+      if @state == :using_spork
+        each_run_procs << block
+      else
+        yield
+      end
     end
-  
-    def preforking!
-      @state = :preforking
+    
+    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 running!
-      @state = :running
+    
+    def using_spork!
+      @state = :using_spork
     end
-  
+    
     def state
       @state ||= :not_using_spork
     end
-  
-    def exec_prefork(helper_file)
-      preforking!
-      load(helper_file)
+    
+    def exec_prefork(&block)
+      using_spork!
+      yield
     end
-  
-    def exec_each_run(helper_file)
-      running!
-      load(helper_file)
+    
+    def exec_each_run(&block)
+      each_run_procs.each { |p| p.call }
+      each_run_procs.clear
+      yield if block_given?
     end
     
     def expanded_caller(caller_line)
@@ -48,5 +53,29 @@ module Spork
       line.gsub(/:.+/, '')
       File.expand_path(Dir.pwd, file) + ":" + line
     end
+    
+    def trap_method(klass, method_name)
+      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)
+          Spork.each_run_procs << lambda do
+            #{method_name}_without_spork(*args)
+          end
+        end
+      EOF
+    end
+    
+    def trap_class_method(klass, method_name)
+      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
+        class << self
+          alias :#{method_name}_without_spork :#{method_name} unless method_defined?(:#{method_name}_without_spork)
+          def #{method_name}(*args)
+            Spork.each_run_procs << lambda do
+              #{method_name}_without_spork(*args)
+            end
+          end
+        end
+      EOF
+    end
   end
 end

data/lib/spork/app_framework.rb

@@ -0,0 +1,46 @@
+class Spork::AppFramework
+  SUPPORTED_FRAMEWORKS = {
+    :Rails => lambda do
+      File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
+    end
+  }
+  
+  def self.detect_framework_name
+    SUPPORTED_FRAMEWORKS.each do |key, value|
+      return key if value.call
+    end
+    :Unknown
+  end
+  
+  def self.detect_framework
+    name = detect_framework_name
+    self[name]
+  end
+  
+  def self.[](name)
+    instances[name] ||= (
+      require File.join(File.dirname(__FILE__), "app_framework", name.to_s.downcase)
+      const_get(name).new
+    )
+  end
+  
+  def self.instances
+    @instances ||= {}
+  end
+  
+  def self.short_name
+    name.gsub('Spork::AppFramework::', '')
+  end
+  
+  def bootstrap_required?
+    raise NotImplemented
+  end
+  
+  def preload(&block)
+    yield
+  end
+  
+  def name
+    self.class.short_name
+  end
+end