Rails 2.1 RC1

Updated Instiki to Rails 2.1 RC1 (aka 2.0.991).

vendor/rails/actionpack/lib/action_controller/dispatcher.rb

@@ -2,27 +2,39 @@ module ActionController
   # Dispatches requests to the appropriate controller and takes care of
   # reloading the app after each request when Dependencies.load? is true.
   class Dispatcher
+    @@guard = Mutex.new
+
     class << self
+      def define_dispatcher_callbacks(cache_classes)
+        unless cache_classes
+          # Development mode callbacks
+          before_dispatch :reload_application
+          after_dispatch :cleanup_application
+        end
+
+        # Common callbacks
+        to_prepare :load_application_controller do
+          begin
+            require_dependency 'application' unless defined?(::ApplicationController)
+          rescue LoadError => error
+            raise unless error.message =~ /application\.rb/
+          end
+        end
+
+        if defined?(ActiveRecord)
+          before_dispatch { ActiveRecord::Base.verify_active_connections! }
+          to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
+        end
+
+        after_dispatch :flush_logger if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
+      end
+
       # Backward-compatible class method takes CGI-specific args. Deprecated
       # in favor of Dispatcher.new(output, request, response).dispatch.
       def dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
         new(output).dispatch_cgi(cgi, session_options)
       end
 
-      # Declare a block to be called before each dispatch.
-      # Run in the order declared.
-      def before_dispatch(*method_names, &block)
-        callbacks[:before].concat method_names
-        callbacks[:before] << block if block_given?
-      end
-
-      # Declare a block to be called after each dispatch.
-      # Run in reverse of the order declared.
-      def after_dispatch(*method_names, &block)
-        callbacks[:after].concat method_names
-        callbacks[:after] << block if block_given?
-      end
-
       # Add a preparation callback. Preparation callbacks are run before every
       # request in development mode, and before the first request in production
       # mode.
@@ -32,16 +44,9 @@ module ActionController
       # 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)
-        # Already registered: update the existing callback
-        if identifier
-          if callback = callbacks[:prepare].assoc(identifier)
-            callback[1] = block
-          else
-            callbacks[:prepare] << [identifier, block]
-          end
-        else
-          callbacks[:prepare] << block
-        end
+        @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
+        callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
+        @prepare_dispatch_callbacks | callback
       end
 
       # If the block raises, send status code as a last-ditch response.
@@ -86,37 +91,26 @@ module ActionController
     end
 
     cattr_accessor :error_file_path
-    self.error_file_path = "#{::RAILS_ROOT}/public" if defined? ::RAILS_ROOT
+    self.error_file_path = Rails.public_path if defined?(Rails.public_path)
 
-    cattr_accessor :callbacks
-    self.callbacks = Hash.new { |h, k| h[k] = [] }
-
-    cattr_accessor :unprepared
-    self.unprepared = true
-
-
-    before_dispatch :reload_application
-    before_dispatch :prepare_application
-    after_dispatch :flush_logger
-    after_dispatch :cleanup_application
-
-    if defined? ActiveRecord
-      to_prepare :activerecord_instantiate_observers do
-        ActiveRecord::Base.instantiate_observers
-      end
-    end
+    include ActiveSupport::Callbacks
+    define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
 
     def initialize(output, request = nil, response = nil)
       @output, @request, @response = output, request, response
     end
 
     def dispatch
-      run_callbacks :before
-      handle_request
-    rescue Exception => exception
-      failsafe_rescue exception
-    ensure
-      run_callbacks :after, :reverse_each
+      @@guard.synchronize do
+        begin
+          run_callbacks :before_dispatch
+          handle_request
+        rescue Exception => exception
+          failsafe_rescue exception
+        ensure
+          run_callbacks :after_dispatch, :enumerator => :reverse_each
+        end
+      end
     end
 
     def dispatch_cgi(cgi, session_options)
@@ -130,39 +124,23 @@ module ActionController
     end
 
     def reload_application
-      if Dependencies.load?
-        Routing::Routes.reload
-        self.unprepared = true
-      end
-    end
+      # Run prepare callbacks before every request in development mode
+      run_callbacks :prepare_dispatch
 
-    def prepare_application(force = false)
-      begin
-        require_dependency 'application' unless defined?(::ApplicationController)
-      rescue LoadError => error
-        raise unless error.message =~ /application\.rb/
-      end
-
-      ActiveRecord::Base.verify_active_connections! if defined?(ActiveRecord)
-
-      if unprepared || force
-        run_callbacks :prepare
-        self.unprepared = false
-      end
+      Routing::Routes.reload
+      ActionView::TemplateFinder.reload! unless ActionView::Base.cache_template_loading
     end
 
     # Cleanup the application by clearing out loaded classes so they can
     # be reloaded on the next request without restarting the server.
-    def cleanup_application(force = false)
-      if Dependencies.load? || force
-        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-        Dependencies.clear
-        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-      end
+    def cleanup_application
+      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+      Dependencies.clear
+      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
     end
 
     def flush_logger
-      RAILS_DEFAULT_LOGGER.flush if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER.respond_to?(:flush)
+      RAILS_DEFAULT_LOGGER.flush
     end
 
     protected
@@ -171,17 +149,6 @@ module ActionController
         @controller.process(@request, @response).out(@output)
       end
 
-      def run_callbacks(kind, enumerator = :each)
-        callbacks[kind].send!(enumerator) do |callback|
-          case callback
-          when Proc; callback.call(self)
-          when String, Symbol; send!(callback)
-          when Array; callback[1].call(self)
-          else raise ArgumentError, "Unrecognized callback #{callback.inspect}"
-          end
-        end
-      end
-
       def failsafe_rescue(exception)
         self.class.failsafe_response(@output, '500 Internal Server Error', exception) do
           if @controller ||= defined?(::ApplicationController) ? ::ApplicationController : Base