milhouse-spork 0.7.5.2 → 0.7.5.4

data/lib/spork.rb

@@ -1,126 +1,126 @@
-$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 == :using_spork
-        each_run_procs << block
-      else
-        yield
-      end
-    end
-    
-    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
-    def using_spork!
-      @state = :using_spork
-    end
-    
-    def using_spork?
-      @state == :using_spork
-    end
-
-    # Used by the server.  Returns the current state of Spork.
-    def state
-      @state ||= :not_using_spork
-    end
-    
-    # Used by the server.  Called when loading the prefork blocks of the code.
-    def exec_prefork(&block)
-      using_spork!
-      yield
-    end
-    
-    # Used by the server.  Called to run all of the prefork blocks.
-    def exec_each_run(&block)
-      each_run_procs.each { |p| p.call }
-      each_run_procs.clear
-      yield if block_given?
-    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)
-          Spork.each_run(false) do
-            #{method_name_without_spork}(*args)
-          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 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(":")
-        line.gsub(/:.+/, '')
-        File.expand_path(file, Dir.pwd) + ":" + line
-      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
-  end
-end
+$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 == :using_spork
+        each_run_procs << block
+      else
+        yield
+      end
+    end
+    
+    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
+    def using_spork!
+      @state = :using_spork
+    end
+    
+    def using_spork?
+      @state == :using_spork
+    end
+
+    # Used by the server.  Returns the current state of Spork.
+    def state
+      @state ||= :not_using_spork
+    end
+    
+    # Used by the server.  Called when loading the prefork blocks of the code.
+    def exec_prefork(&block)
+      using_spork!
+      yield
+    end
+    
+    # Used by the server.  Called to run all of the prefork blocks.
+    def exec_each_run(&block)
+      each_run_procs.each { |p| p.call }
+      each_run_procs.clear
+      yield if block_given?
+    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)
+          Spork.each_run(false) do
+            #{method_name_without_spork}(*args)
+          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 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(":")
+        line.gsub(/:.+/, '')
+        File.expand_path(file, Dir.pwd) + ":" + line
+      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
+  end
+end

data/lib/spork/app_framework.rb

@@ -1,74 +1,74 @@
-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 = {
-    :Rails => lambda {
-      File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
-    }
-  } 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
-
+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 = {
+    :Rails => lambda {
+      File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
+    }
+  } 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/rails.rb

@@ -1,158 +1,158 @@
-class Spork::AppFramework::Rails < Spork::AppFramework
-  
-  # TODO - subclass this out to handle different versions of rails
-  # Also... this is the nastiest duck punch ever.  Clean this up.
-  module NinjaPatcher
-    def self.included(klass)
-      klass.class_eval do
-        unless method_defined?(:load_environment_without_spork)
-          alias :load_environment_without_spork :load_environment
-          alias :load_environment :load_environment_with_spork
-        end
-        
-        def self.run_with_spork(*args, &block) # it's all fun and games until someone gets an eye poked out
-          if ENV['RAILS_ENV']
-            Object.send(:remove_const, :RAILS_ENV)
-            Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
-          end
-          run_without_spork(*args, &block)
-        end
-        
-        class << self
-          unless method_defined?(:run_without_spork)
-            alias :run_without_spork :run
-            alias :run :run_with_spork
-          end
-        end
-      end
-    end
-    
-    def load_environment_with_spork
-      result = load_environment_without_spork
-      install_hooks
-      result
-    end
-    
-    def install_hooks
-      auto_reestablish_db_connection
-      delay_observer_loading
-      delay_app_preload
-      delay_application_controller_loading
-      delay_route_loading
-      delay_eager_view_loading
-    end
-    
-    def reset_rails_env
-      return unless ENV['RAILS_ENV']
-      Object.send(:remove_const, :RAILS_ENV)
-      Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
-    end
-    
-    def delay_observer_loading
-      if ::Rails::Initializer.instance_methods.include?('load_observers')
-        Spork.trap_method(::Rails::Initializer, :load_observers)
-      end
-      if Object.const_defined?(:ActionController)
-        require "action_controller/dispatcher.rb"
-        Spork.trap_class_method(::ActionController::Dispatcher, :define_dispatcher_callbacks) if ActionController::Dispatcher.respond_to?(:define_dispatcher_callbacks)
-      end
-    end
-    
-    def delay_app_preload
-      if ::Rails::Initializer.instance_methods.include?('load_application_classes')
-        Spork.trap_method(::Rails::Initializer, :load_application_classes)
-      end
-    end
-    
-    def delay_application_controller_loading
-      if application_controller_source = ["#{Dir.pwd}/app/controllers/application.rb", "#{Dir.pwd}/app/controllers/application_controller.rb"].find { |f| File.exist?(f) }
-        application_helper_source = "#{Dir.pwd}/app/helpers/application_helper.rb"
-        load_paths = (::ActiveSupport.const_defined?(:Dependencies) ? ::ActiveSupport::Dependencies : ::Dependencies).load_paths
-        load_paths.unshift(File.expand_path('rails_stub_files', File.dirname(__FILE__)))
-        Spork.each_run do
-          require application_controller_source
-          require application_helper_source if File.exist?(application_helper_source)
-          # update the rails magic to refresh the module
-          ApplicationController.send(:helper, ApplicationHelper)
-        end
-      end
-    end
-    
-    def auto_reestablish_db_connection
-      if Object.const_defined?(:ActiveRecord)
-        Spork.each_run do
-          # rails lib/test_help.rb is very aggressive about overriding RAILS_ENV and will switch it back to test after the cucumber env was loaded
-          reset_rails_env
-          ActiveRecord::Base.establish_connection
-        end
-      end
-    end
-    
-    def delay_route_loading
-      if ::Rails::Initializer.instance_methods.include?('initialize_routing')
-        Spork.trap_method(::Rails::Initializer, :initialize_routing)
-      end
-    end
-    
-    def delay_eager_view_loading
-      # So, in testing mode it seems it would be optimal to not eager load 
-      # views (as your may only run a test that uses one or two views).
-      # However, I decided to delay eager loading rather than force it to 
-      # disable because you may wish to eager load your views (I.E. you're 
-      # testing concurrency)
-      
-      # Rails 2.3.x +
-      if defined?(::ActionView::Template::EagerPath)
-        Spork.trap_method(::ActionView::Template::EagerPath, :load!)
-      end
-      # Rails 2.2.x
-      if defined?(::ActionView::PathSet::Path)
-        Spork.trap_method(::ActionView::PathSet::Path, :load)
-      end
-      # Rails 2.0.5 - 2.1.x don't appear to eager cache views.
-    end
-  end
-  
-  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 environment_contents
-    @environment_contents ||= File.read(environment_file)
-  end
-  
-  def vendor
-    @vendor ||= File.expand_path("vendor/rails", Dir.pwd)
-  end
-  
-  def version
-    @version ||= (
-      if /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/.match(environment_contents)
-        $1
-      else
-        nil
-      end
-    )
-  end
-  
-  def preload_rails
-    Object.const_set(:RAILS_GEM_VERSION, version) if version
-    require boot_file
-    ::Rails::Initializer.send(:include, Spork::AppFramework::Rails::NinjaPatcher)
-  end
-  
+class Spork::AppFramework::Rails < Spork::AppFramework
+  
+  # TODO - subclass this out to handle different versions of rails
+  # Also... this is the nastiest duck punch ever.  Clean this up.
+  module NinjaPatcher
+    def self.included(klass)
+      klass.class_eval do
+        unless method_defined?(:load_environment_without_spork)
+          alias :load_environment_without_spork :load_environment
+          alias :load_environment :load_environment_with_spork
+        end
+        
+        def self.run_with_spork(*args, &block) # it's all fun and games until someone gets an eye poked out
+          if ENV['RAILS_ENV']
+            Object.send(:remove_const, :RAILS_ENV)
+            Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
+          end
+          run_without_spork(*args, &block)
+        end
+        
+        class << self
+          unless method_defined?(:run_without_spork)
+            alias :run_without_spork :run
+            alias :run :run_with_spork
+          end
+        end
+      end
+    end
+    
+    def load_environment_with_spork
+      result = load_environment_without_spork
+      install_hooks
+      result
+    end
+    
+    def install_hooks
+      auto_reestablish_db_connection
+      delay_observer_loading
+      delay_app_preload
+      delay_application_controller_loading
+      delay_route_loading
+      delay_eager_view_loading
+    end
+    
+    def reset_rails_env
+      return unless ENV['RAILS_ENV']
+      Object.send(:remove_const, :RAILS_ENV)
+      Object.const_set(:RAILS_ENV, ENV['RAILS_ENV'].dup)
+    end
+    
+    def delay_observer_loading
+      if ::Rails::Initializer.instance_methods.include?('load_observers')
+        Spork.trap_method(::Rails::Initializer, :load_observers)
+      end
+      if Object.const_defined?(:ActionController)
+        require "action_controller/dispatcher.rb"
+        Spork.trap_class_method(::ActionController::Dispatcher, :define_dispatcher_callbacks) if ActionController::Dispatcher.respond_to?(:define_dispatcher_callbacks)
+      end
+    end
+    
+    def delay_app_preload
+      if ::Rails::Initializer.instance_methods.include?('load_application_classes')
+        Spork.trap_method(::Rails::Initializer, :load_application_classes)
+      end
+    end
+    
+    def delay_application_controller_loading
+      if application_controller_source = ["#{Dir.pwd}/app/controllers/application.rb", "#{Dir.pwd}/app/controllers/application_controller.rb"].find { |f| File.exist?(f) }
+        application_helper_source = "#{Dir.pwd}/app/helpers/application_helper.rb"
+        load_paths = (::ActiveSupport.const_defined?(:Dependencies) ? ::ActiveSupport::Dependencies : ::Dependencies).load_paths
+        load_paths.unshift(File.expand_path('rails_stub_files', File.dirname(__FILE__)))
+        Spork.each_run do
+          require application_controller_source
+          require application_helper_source if File.exist?(application_helper_source)
+          # update the rails magic to refresh the module
+          ApplicationController.send(:helper, ApplicationHelper)
+        end
+      end
+    end
+    
+    def auto_reestablish_db_connection
+      if Object.const_defined?(:ActiveRecord)
+        Spork.each_run do
+          # rails lib/test_help.rb is very aggressive about overriding RAILS_ENV and will switch it back to test after the cucumber env was loaded
+          reset_rails_env
+          ActiveRecord::Base.establish_connection
+        end
+      end
+    end
+    
+    def delay_route_loading
+      if ::Rails::Initializer.instance_methods.include?('initialize_routing')
+        Spork.trap_method(::Rails::Initializer, :initialize_routing)
+      end
+    end
+    
+    def delay_eager_view_loading
+      # So, in testing mode it seems it would be optimal to not eager load 
+      # views (as your may only run a test that uses one or two views).
+      # However, I decided to delay eager loading rather than force it to 
+      # disable because you may wish to eager load your views (I.E. you're 
+      # testing concurrency)
+      
+      # Rails 2.3.x +
+      if defined?(::ActionView::Template::EagerPath)
+        Spork.trap_method(::ActionView::Template::EagerPath, :load!)
+      end
+      # Rails 2.2.x
+      if defined?(::ActionView::PathSet::Path)
+        Spork.trap_method(::ActionView::PathSet::Path, :load)
+      end
+      # Rails 2.0.5 - 2.1.x don't appear to eager cache views.
+    end
+  end
+  
+  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 environment_contents
+    @environment_contents ||= File.read(environment_file)
+  end
+  
+  def vendor
+    @vendor ||= File.expand_path("vendor/rails", Dir.pwd)
+  end
+  
+  def version
+    @version ||= (
+      if /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/.match(environment_contents)
+        $1
+      else
+        nil
+      end
+    )
+  end
+  
+  def preload_rails
+    Object.const_set(:RAILS_GEM_VERSION, version) if version
+    require boot_file
+    ::Rails::Initializer.send(:include, Spork::AppFramework::Rails::NinjaPatcher)
+  end
+  
 end