Move Railties' Dispatcher to ActionController::Dispatcher, introduce before_ and after_dispatch callbacks, and warm up to non-CGI requests.

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@7640 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

6 files changed, 15 insertions, 284 deletions

diff --git a/railties/CHANGELOG b/railties/CHANGELOG
index 3f77a2f37b..241278de71 100644
--- a/railties/CHANGELOG
+++ b/railties/CHANGELOG
@@ -1,5 +1,7 @@
 *SVN*
 
+* Moved Dispatcher to ActionController::Dispatcher.  [Jeremy Kemper]
+
 * Changed the default logger from Ruby's own Logger with the clean_logger extensions to ActiveSupport::BufferedLogger for performance reasons [DHH]. (You can change it back with config.logger = Logger.new("/path/to/log", level).)
 
 * Added a default 422.html page to be rendered when ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved, or ActionController::InvalidAuthenticityToken is raised [DHH]
diff --git a/railties/Rakefile b/railties/Rakefile
index 0df22c7a72..04a1162c74 100644
--- a/railties/Rakefile
+++ b/railties/Rakefile
@@ -21,6 +21,8 @@ RUBY_FORGE_PROJECT = "rails"
 RUBY_FORGE_USER    = "webster132"
 
 
+task :default => :test
+
 ## This is required until the regular test task
 ## below passes.  It's not ideal, but at least
 ## we can see the failures
@@ -353,4 +355,4 @@ task :release => [ :package ] do
   rubyforge = RubyForge.new
   rubyforge.login
   rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
-end
\ No newline at end of file
+end
diff --git a/railties/lib/console_app.rb b/railties/lib/console_app.rb
index eaf02234ea..c7673642ec 100644
--- a/railties/lib/console_app.rb
+++ b/railties/lib/console_app.rb
@@ -23,7 +23,8 @@ end
 #reloads the environment
 def reload!
   puts "Reloading..."
-  returning Dispatcher.reset_application! do
-    Dispatcher.send :run_preparation_callbacks
-  end
+  dispatcher = ActionController::Dispatcher.new($stdout)
+  dispatcher.cleanup_application(true)
+  dispatcher.prepare_application(true)
+  true
 end
diff --git a/railties/lib/dispatcher.rb b/railties/lib/dispatcher.rb
index 398acb7e97..9db424f14b 100644
--- a/railties/lib/dispatcher.rb
+++ b/railties/lib/dispatcher.rb
@@ -20,162 +20,5 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
-
-# This class provides an interface for dispatching a CGI (or CGI-like) request
-# to the appropriate controller and action. It also takes care of resetting
-# the environment (when Dependencies.load? is true) after each request.
-class Dispatcher
-  class << self
-    # Dispatch the given CGI request, using the given session options, and
-    # emitting the output via the given output.  If you dispatch with your
-    # own CGI object be sure to handle the exceptions it raises on multipart
-    # requests (EOFError and ArgumentError).
-    def dispatch(cgi = nil, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
-      controller = nil
-      if cgi ||= new_cgi(output)
-        request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
-        prepare_application
-        controller = ActionController::Routing::Routes.recognize(request)
-        controller.process(request, response).out(output)
-      end
-    rescue Exception => exception # errors from CGI dispatch
-      failsafe_response(cgi, output, '500 Internal Server Error', exception) do
-        controller ||= (ApplicationController rescue ActionController::Base)
-        controller.process_with_exception(request, response, exception).out(output)
-      end
-    ensure
-      # Do not give a failsafe response here
-      flush_logger
-      reset_after_dispatch
-    end
-
-    # Reset the application by clearing out loaded controllers, views, actions,
-    # mailers, and so forth. This allows them to be loaded again without having
-    # to restart the server (WEBrick, FastCGI, etc.).
-    def reset_application!
-      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-
-      Dependencies.clear
-
-      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-    end
-
-    # Add a preparation callback. Preparation callbacks are run before every
-    # request in development mode, and before the first request in production
-    # mode.
-    # 
-    # An optional identifier may be supplied for the callback. If provided,
-    # to_prepare may be called again with the same identifier to replace the
-    # existing callback. Passing an identifier is a suggested practice if the
-    # code adding a preparation block may be reloaded.
-    def to_prepare(identifier = nil, &block)
-      unless identifier.nil?
-        callback = preparation_callbacks.detect { |ident, _| ident == identifier }
-
-        if callback # Already registered: update the existing callback
-          callback[-1] = block
-          return
-        end
-      end
-
-      preparation_callbacks << [identifier, block]
-
-      return
-    end
-
-    private
-      attr_accessor_with_default :preparation_callbacks, []
-      attr_accessor_with_default :preparation_callbacks_run, false
-
-      # CGI.new plus exception handling.  CGI#read_multipart raises EOFError
-      # if body.empty? or body.size != Content-Length and raises ArgumentError
-      # if Content-Length is non-integer.
-      def new_cgi(output)
-        failsafe_response(nil, output, '400 Bad Request') { CGI.new }
-      end
-
-      def prepare_application
-        if Dependencies.load?
-          ActionController::Routing::Routes.reload
-          self.preparation_callbacks_run = false
-        end
-
-        require_dependency 'application' unless Object.const_defined?(:ApplicationController)
-        ActiveRecord::Base.verify_active_connections! if defined?(ActiveRecord)
-        run_preparation_callbacks
-      end
-
-      def reset_after_dispatch
-        reset_application! if Dependencies.load?
-      end
-
-      def run_preparation_callbacks
-        return if preparation_callbacks_run
-        preparation_callbacks.each { |_, callback| callback.call }
-        self.preparation_callbacks_run = true
-      end
-
-      # If the block raises, send status code as a last-ditch response.
-      def failsafe_response(cgi, fallback_output, status, exception = nil)
-        yield
-      rescue Exception
-        begin
-          log_failsafe_exception(cgi, status, exception)
-
-          body = failsafe_response_body(status)
-          if cgi
-            head = { 'status' => status, 'type' => 'text/html' }
-
-            # FIXME: using CGI differently than CGIResponse does breaks
-            # the Mongrel CGI wrapper.
-            if defined?(Mongrel) && cgi.is_a?(Mongrel::CGIWrapper)
-              # FIXME: set a dummy cookie so the Mongrel CGI wrapper will
-              # also consider @output_cookies (used for session cookies.)
-              head['cookie'] = []
-              cgi.header(head)
-              fallback_output << body
-            else
-              cgi.out(head) { body }
-            end
-          else
-            fallback_output.write "Status: #{status}\r\nContent-Type: text/html\r\n\r\n#{body}"
-          end
-          nil
-        rescue Exception  # Logger or IO errors
-        end
-      end
-
-      def failsafe_response_body(status)
-        error_path = "#{RAILS_ROOT}/public/#{status[0..3]}.html"
-
-        if File.exists?(error_path)
-          File.read(error_path)
-        else
-          "<html><body><h1>#{status}</h1></body></html>"
-        end
-      end
-
-      def log_failsafe_exception(cgi, status, exception)
-        fell_back = cgi ? 'has cgi' : 'no cgi, fallback ouput'
-        message = "DISPATCHER FAILSAFE RESPONSE (#{fell_back}) #{Time.now}\n  Status: #{status}\n"
-        message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
-        failsafe_logger.fatal message
-      end
-
-      def failsafe_logger
-        if defined?(RAILS_DEFAULT_LOGGER) && !RAILS_DEFAULT_LOGGER.nil?
-          RAILS_DEFAULT_LOGGER
-        else
-          ActiveSupport::BufferedLogger.new($stderr)
-        end
-      end
-      
-      def flush_logger
-        RAILS_DEFAULT_LOGGER.flush if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
-      end
-  end
-end
-
-Dispatcher.to_prepare :activerecord_instantiate_observers do
-  ActiveRecord::Base.instantiate_observers
-end if defined?(ActiveRecord)
+require 'action_controller/dispatcher'
+Dispatcher = ActionController::Dispatcher
diff --git a/railties/test/console_app_test.rb b/railties/test/console_app_test.rb
index 0e6019df44..ac499e0f15 100644
--- a/railties/test/console_app_test.rb
+++ b/railties/test/console_app_test.rb
@@ -2,6 +2,10 @@ require File.dirname(__FILE__) + '/abstract_unit'
 
 require 'action_controller' # console_app uses 'action_controller/integration'
 
+unless defined? ApplicationController
+  class ApplicationController < ActionController::Base; end
+end
+
 require 'dispatcher'
 require 'console_app'
 
diff --git a/railties/test/dispatcher_test.rb b/railties/test/dispatcher_test.rb
deleted file mode 100644
index 081d21f8d8..0000000000
--- a/railties/test/dispatcher_test.rb
+++ /dev/null
@@ -1,121 +0,0 @@
-require "#{File.dirname(__FILE__)}/abstract_unit"
-
-uses_mocha 'dispatcher tests' do
-
-$:.unshift File.dirname(__FILE__) + "/../../actionmailer/lib"
-
-require 'stringio'
-require 'cgi'
-
-require 'dispatcher'
-require 'action_controller'
-require 'action_mailer'
-
-
-class DispatcherTest < Test::Unit::TestCase
-  def setup
-    @output = StringIO.new
-    ENV['REQUEST_METHOD'] = "GET"
-
-    Dispatcher.send(:preparation_callbacks).clear
-    Dispatcher.send(:preparation_callbacks_run=, false)
-
-    Object.const_set 'ApplicationController', nil
-  end
-
-  def teardown
-    ENV['REQUEST_METHOD'] = nil
-    Object.send :remove_const, 'ApplicationController'
-  end
-
-  def test_clears_dependencies_after_dispatch_if_in_loading_mode
-    Dependencies.stubs(:load?).returns(true)
-
-    ActionController::Routing::Routes.expects(:reload).once
-    Dependencies.expects(:clear).once
-
-    dispatch
-  end
-
-  def test_clears_dependencies_after_dispatch_if_not_in_loading_mode
-    Dependencies.stubs(:load?).returns(false)
-
-    ActionController::Routing::Routes.expects(:reload).never
-    Dependencies.expects(:clear).never
-
-    dispatch
-  end
-
-  def test_failsafe_response
-    CGI.expects(:new).raises('some multipart parsing failure')
-
-    ActionController::Routing::Routes.stubs(:reload)
-    Dispatcher.stubs(:log_failsafe_exception)
-
-    assert_nothing_raised { dispatch }
-
-    assert_equal "Status: 400 Bad Request\r\nContent-Type: text/html\r\n\r\n<html><body><h1>400 Bad Request</h1></body></html>", @output.string
-  end
-
-  def test_preparation_callbacks
-    ActionController::Routing::Routes.stubs(:reload)
-
-    old_mechanism = Dependencies.mechanism
-    
-    a = b = c = nil
-    Dispatcher.to_prepare { a = b = c = 1 }
-    Dispatcher.to_prepare { b = c = 2 }
-    Dispatcher.to_prepare { c = 3 }
-    
-    Dispatcher.send :prepare_application
-    
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-    
-    # When mechanism is :load, perform the callbacks each request:
-    Dependencies.mechanism = :load
-    a = b = c = nil
-    Dispatcher.send :prepare_application
-    assert_equal 1, a
-    assert_equal 2, b
-    assert_equal 3, c
-    
-    # But when not :load, make sure they are only run once
-    a = b = c = nil
-    Dependencies.mechanism = :not_load
-    Dispatcher.send :prepare_application
-    assert_equal nil, a || b || c
-  ensure
-    Dependencies.mechanism = old_mechanism
-  end
-  
-  def test_to_prepare_with_identifier_replaces
-    ActionController::Routing::Routes.stubs(:reload)
-
-    a = b = nil
-    Dispatcher.to_prepare(:unique_id) { a = b = 1 }
-    Dispatcher.to_prepare(:unique_id) { a = 2 }
-    
-    Dispatcher.send :prepare_application
-    assert_equal 2, a
-    assert_equal nil, b
-  end
-
-  private
-    def dispatch(output = @output)
-      controller = mock
-      controller.stubs(:process).returns(controller)
-      controller.stubs(:out).with(output).returns('response')
-
-      ActionController::Routing::Routes.stubs(:recognize).returns(controller)
-
-      Dispatcher.dispatch(nil, {}, output)
-    end
-
-    def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
-      assert_equal howmany, klass.subclasses.size, message
-    end
-end
-
-end # uses_mocha