spork 0.9.0.rc8-x86-mingw32

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

data/lib/spork/app_framework/padrino.rb

@@ -0,0 +1,22 @@
+class Spork::AppFramework::Padrino < Spork::AppFramework
+  
+  def preload(&block)
+    STDERR.puts "Preloading Padrino environment"
+    STDERR.flush
+    ENV["PADRINO_ENV"] ||= "test"
+    require boot_file
+    # Make it so that we don't have to restart Spork if we change, say, a model or routes
+    Spork.each_run { ::Padrino.reload! }
+    yield
+  end
+  
+  def entry_point
+    @entry_point ||= File.expand_path("config/boot.rb", Dir.pwd)
+  end
+  alias :boot_file :entry_point
+  
+  def boot_contents
+    @boot_contents ||= File.read(boot_file)
+  end
+  
+end

data/lib/spork/app_framework/rails.rb

@@ -0,0 +1,82 @@
+class Spork::AppFramework::Rails < Spork::AppFramework
+
+  def preload(&block)
+    STDERR.puts "Preloading Rails environment"
+    STDERR.flush
+    ENV["RAILS_ENV"] ||= 'test'
+    preload_rails
+    yield
+  end
+
+  def entry_point
+    @entry_point ||= File.expand_path("config/environment.rb", Dir.pwd)
+  end
+
+  alias :environment_file :entry_point
+
+  def boot_file
+    @boot_file ||= File.join(File.dirname(environment_file), 'boot')
+  end
+
+  def application_file
+    @application_file ||= File.join(File.dirname(environment_file), 'application')
+  end
+
+  def environment_contents
+    @environment_contents ||= File.read(environment_file)
+  end
+
+  def vendor
+    @vendor ||= File.expand_path("vendor/rails", Dir.pwd)
+  end
+
+  def deprecated_version
+    @version ||= (
+      if /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/.match(environment_contents)
+        $1
+      else
+        nil
+      end
+    )
+  end
+
+  def preload_rails
+    if deprecated_version && (not /^3/.match(deprecated_version))
+      puts "This version of spork only supports Rails 3.0. To use spork with rails 2.3.x, downgrade to spork 0.8.x."
+      exit 1
+    end
+    require application_file
+    ::Rails.application
+    ::Rails::Engine.class_eval do
+      def eager_load!
+        # turn off eager_loading, all together
+      end
+    end
+    # Spork.trap_method(::AbstractController::Helpers::ClassMethods, :helper)
+    Spork.trap_method(::ActiveModel::Observing::ClassMethods, :instantiate_observers)
+    Spork.each_run { ActiveRecord::Base.establish_connection rescue nil } if Object.const_defined?(:ActiveRecord)
+
+
+    AbstractController::Helpers::ClassMethods.module_eval do
+      def helper(*args, &block)
+        ([args].flatten - [:all]).each do |arg|
+          next unless arg.is_a?(String)
+          filename = arg + "_helper"
+          unless ::ActiveSupport::Dependencies.search_for_file(filename)
+            # this error message must raise in the format such that LoadError#path returns the filename
+            raise LoadError.new("Missing helper file helpers/%s.rb" % filename)
+          end
+        end
+
+        Spork.each_run(false) do
+          modules_for_helpers(args).each do |mod|
+            add_template_helper(mod)
+          end
+
+          _helpers.module_eval(&block) if block_given?
+        end
+      end
+    end
+  end
+
+end

data/lib/spork/app_framework/unknown.rb

@@ -0,0 +1,6 @@
+# This is used if no supported appliction framework is detected
+class Spork::AppFramework::Unknown < Spork::AppFramework
+  def entry_point
+    nil
+  end
+end

data/lib/spork/custom_io_streams.rb

@@ -0,0 +1,25 @@
+# This class is mainly used for testing.
+# When included (and used), it gives us an opportunity to stub out the output streams used for a given class
+module Spork::CustomIOStreams
+  def self.included(klass)
+    klass.send(:extend, ::Spork::CustomIOStreams::ClassMethods)
+  end
+  
+  def stderr
+    self.class.stderr
+  end
+
+  def stdout
+    self.class.stdout
+  end
+  
+  module ClassMethods
+    def stderr
+      $stderr
+    end
+  
+    def stdout
+      $stdout
+    end
+  end
+end

data/lib/spork/diagnoser.rb

@@ -0,0 +1,105 @@
+# The Diagnoser hooks into load and require and keeps track of when files are required / loaded, and who loaded them.
+# It's used when you run spork --diagnose
+#
+# = Example
+#  
+#  Spork::Diagnoser.install_hook!('/path/env.rb', '/path')
+#  require '/path/to/env.rb'
+#  Spork::Diagnoser.output_results(STDOUT)
+class Spork::Diagnoser
+  class << self
+    def loaded_files
+      @loaded_files ||= {}
+    end
+    
+    # Installs the diagnoser hook into Kernel#require and Kernel#load
+    #
+    # == Parameters
+    #
+    # * +entry_file+ - The file that is used to load the project.  Used to filter the backtrace so anything that happens after it is hidden.
+    # * +dir+ - The project directory.  Any file loaded outside of this directory will not be logged.
+    def install_hook!(entry_file = nil, dir = Dir.pwd)
+      @dir = File.expand_path(Dir.pwd, dir)
+      @entry_file = entry_file
+      
+      Kernel.class_eval do
+        alias :require_without_diagnoser :require
+        alias :load_without_diagnoser :load
+        
+        def require(string)
+          ::Spork::Diagnoser.add_included_file(string, caller)
+          require_without_diagnoser(string)
+        end
+        private :require
+        
+        def load(string)
+          ::Spork::Diagnoser.add_included_file(string, caller)
+          load_without_diagnoser(string)
+        end
+        private :load
+      end
+    end
+    
+    def add_included_file(filename, callstack)
+      filename = expand_filename(filename)
+      return unless File.exist?(filename)
+      loaded_files[filename] = filter_callstack(caller) if subdirectory?(filename)
+    end
+    
+    # Uninstall the hook. Generally useful only for testing the Diagnoser.
+    def remove_hook!
+      return unless Kernel.private_instance_methods.map(&:to_sym).include?(:require_without_diagnoser)
+      Kernel.class_eval do
+        alias :require :require_without_diagnoser
+        alias :load :load_without_diagnoser
+        
+        undef_method(:require_without_diagnoser)
+        undef_method(:load_without_diagnoser)
+      end
+      true
+    end
+    
+    # output the results of a diagnostic run.
+    #
+    # == Parameters
+    #
+    # * +stdout+ - An IO stream to output the results to.
+    def output_results(stdout)
+      project_prefix = Dir.pwd + "/"
+      minimify = lambda { |f| f.gsub(project_prefix, '')}
+      stdout.puts "- Spork Diagnosis -\n"
+      stdout.puts "-- Summary --"
+      stdout.puts loaded_files.keys.sort.map(&minimify)
+      stdout.puts "\n\n\n"
+      stdout.puts "-- Detail --"
+      loaded_files.keys.sort.each do |file|
+        stdout.puts "\n\n\n--- #{minimify.call(file)} ---\n"
+        stdout.puts loaded_files[file].map(&minimify)
+      end
+    end
+    
+    private
+      def filter_callstack(callstack, entry_file = @entry_file)
+        callstack.pop until callstack.empty? || callstack.last.include?(@entry_file) if @entry_file
+        callstack.map do |line|
+          next if line.include?('lib/spork/diagnoser.rb')
+          line.gsub!('require_without_diagnoser', 'require')
+          line
+        end.compact
+      end
+    
+      def expand_filename(filename)
+        ([Dir.pwd] + $:).each do |attempted_path|
+          attempted_filename = File.expand_path(filename, attempted_path)
+          return attempted_filename if File.file?(attempted_filename)
+          attempted_filename = attempted_filename + ".rb"
+          return attempted_filename if File.file?(attempted_filename)
+        end
+        filename
+      end
+    
+      def subdirectory?(directory)
+        File.expand_path(directory, Dir.pwd).include?(@dir)
+      end
+  end
+end

data/lib/spork/ext/rails-reloader.rb

@@ -0,0 +1,14 @@
+Spork.each_run do
+  ::ActiveSupport.const_defined?(:Dependencies) ?
+    ::ActiveSupport::Dependencies.mechanism = :load :
+    ::Dependencies.mechanism = :load
+
+  require 'action_controller/dispatcher'
+  dispatcher = ::ActionController::Dispatcher.new($stdout)
+
+  if ::ActionController::Dispatcher.respond_to?(:reload_application)
+    ::ActionController::Dispatcher.reload_application
+  else
+    dispatcher.reload_application
+  end
+end if Spork.using_spork?

data/lib/spork/ext/ruby-debug.rb

@@ -0,0 +1,150 @@
+require 'socket'
+require 'forwardable'
+
+begin
+require 'ruby-debug'
+
+# Experimental!
+
+class SporkDebugger
+  DEFAULT_PORT = 10_123
+  HOST = '127.0.0.1'
+
+  extend Forwardable
+  def_delegators :state, *[:prepare_debugger, :initialize]
+  attr_reader :state
+
+  class << self
+    attr_reader :instance
+    def run
+      @instance ||= new
+    end
+  end
+
+  def initialize
+    @state = SporkDebugger::PreloadState.new
+    Spork.send(:each_run_procs).unshift(lambda do
+      @state = @state.transition_to_each_run_state
+    end)
+  end
+
+  module NetworkHelpers
+    def find_port(starting_with)
+      port = starting_with
+      begin
+        server = TCPServer.new(HOST, port)
+        server.close
+      rescue Errno::EADDRINUSE
+        port += 1
+        retry
+      end
+
+      port
+    end
+  end
+
+  class PreloadState
+    include NetworkHelpers
+    def initialize
+      Spork.each_run { install_hook }
+      listen_for_connection_signals
+    end
+
+    def finish
+      @tcp_service.close; @tcp_service = nil;
+    end
+
+    def transition_to_each_run_state
+      finish
+      SporkDebugger::EachRunState.new(@port)
+    end
+
+    protected
+      def install_hook
+        Kernel.class_eval do
+          alias :debugger_without_spork_hook :debugger
+          def debugger(steps = 1)
+            SporkDebugger.instance.prepare_debugger
+            debugger_without_spork_hook
+          end
+        end
+      end
+
+      def listen_for_connection_signals
+        @port = SporkDebugger::DEFAULT_PORT
+        begin
+          @tcp_service = TCPServer.new(SporkDebugger::HOST, @port)
+        rescue Errno::EADDRINUSE
+          @port += 1
+          retry
+        end
+        Thread.new { main_loop }
+      end
+
+      def main_loop
+        while @tcp_service do
+          socket = @tcp_service.accept
+          port = Marshal.load(socket)
+          Marshal.dump(true, socket)
+          connect_rdebug_client(port)
+          socket.close
+        end
+      rescue => e
+        puts "error: #{e.class} - #{e}"
+      end
+
+      def connect_rdebug_client(port = Debugger::PORT)
+        puts "\n\n - Debug Session Started - \n\n\n"
+        begin
+          Debugger.start_client(SporkDebugger::HOST, port)
+        rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNREFUSED
+        end
+        puts "\n\n - Debug Session Terminated - \n\n\n"
+      end
+  end
+
+  class EachRunState
+    include NetworkHelpers
+    def initialize(connection_request_port)
+      @connection_request_port = connection_request_port
+    end
+
+    def prepare_debugger
+      return if @debugger_prepared
+      @debugger_prepared = true
+      port, cport = start_rdebug_server
+      signal_spork_server_to_connect_to_rdebug_server(port)
+      wait_for_connection
+      puts "\n\n - breakpoint - see your spork server for the debug terminal - \n\n"
+    end
+
+    def signal_spork_server_to_connect_to_rdebug_server(rdebug_server_port)
+      socket = TCPSocket.new(SporkDebugger::HOST, @connection_request_port)
+      Marshal.dump(rdebug_server_port, socket)
+      response = Marshal.load(socket)
+      socket.close
+    end
+
+    def start_rdebug_server
+      Debugger.stop if Debugger.started?
+      port = find_port(Debugger::PORT)
+      cport = find_port(port + 1)
+      Debugger.start_remote(SporkDebugger::HOST, [port, cport]) do
+        Debugger.run_init_script(StringIO.new)
+      end
+      Debugger.start
+      [port, cport]
+    end
+
+    protected
+      def wait_for_connection
+        while Debugger.handler.interface.nil?; sleep 0.10; end
+      end
+  end
+end
+
+Spork.prefork { SporkDebugger.run } if Spork.using_spork?
+
+rescue LoadError
+  raise LoadError, "Your project has loaded spork/ext/ruby-debug, which relies on the ruby-debug gem. It appears that ruby-debug is not installed. Please install it."
+end