Merge commit 'mainstream/master'

6 files changed, 94 insertions, 80 deletions

diff --git a/actionpack/lib/action_controller/dispatcher.rb b/actionpack/lib/action_controller/dispatcher.rb
index e91babde10..ec40b5c4e6 100644
--- a/actionpack/lib/action_controller/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatcher.rb
@@ -5,8 +5,9 @@ module ActionController
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
-          # Development mode callbacks
-          before_dispatch :reload_application
+          unless self.middleware.include?(Reloader)
+            self.middleware.insert_after(Failsafe, Reloader)
+          end
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
@@ -41,6 +42,30 @@ module ActionController
         callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
         @prepare_dispatch_callbacks.replace_or_append!(callback)
       end
+
+      def run_prepare_callbacks
+        if defined?(Rails) && Rails.logger
+          logger = Rails.logger
+        else
+          logger = Logger.new($stderr)
+        end
+
+        new(logger).send :run_callbacks, :prepare_dispatch
+      end
+
+      def reload_application
+        # Run prepare callbacks before every request in development mode
+        run_prepare_callbacks
+
+        Routing::Routes.reload
+      end
+
+      def cleanup_application
+        # Cleanup the application before processing the current request.
+        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+        ActiveSupport::Dependencies.clear
+        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
+      end
     end
 
     cattr_accessor :middleware
@@ -87,18 +112,6 @@ module ActionController
       dispatch
     end
 
-    def reload_application
-      # Cleanup the application before processing the current request.
-      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-      ActiveSupport::Dependencies.clear
-      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-
-      # Run prepare callbacks before every request in development mode
-      run_callbacks :prepare_dispatch
-
-      Routing::Routes.reload
-    end
-
     def flush_logger
       Base.logger.flush
     end
diff --git a/actionpack/lib/action_controller/layout.rb b/actionpack/lib/action_controller/layout.rb
index d6bcf7a8c1..a0db7acf72 100644
--- a/actionpack/lib/action_controller/layout.rb
+++ b/actionpack/lib/action_controller/layout.rb
@@ -172,23 +172,10 @@ module ActionController #:nodoc:
         @layout_conditions ||= read_inheritable_attribute(:layout_conditions)
       end
 
-      def default_layout(format) #:nodoc:
-        layout = read_inheritable_attribute(:layout) unless format == :js
-        return layout unless read_inheritable_attribute(:auto_layout)
-        find_layout(layout, format)
-      end
-
       def layout_list #:nodoc:
         Array(view_paths).sum([]) { |path| Dir["#{path.to_str}/layouts/**/*"] }
       end
 
-      def find_layout(layout, *formats) #:nodoc:
-        return layout if layout.respond_to?(:render)
-        view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", *formats)
-      rescue ActionView::MissingTemplate
-        nil
-      end
-
       private
         def inherited_with_layout(child)
           inherited_without_layout(child)
@@ -212,35 +199,29 @@ module ActionController #:nodoc:
     # object). If the layout was defined without a directory, layouts is assumed. So <tt>layout "weblog/standard"</tt> will return
     # weblog/standard, but <tt>layout "standard"</tt> will return layouts/standard.
     def active_layout(passed_layout = nil)
-      layout = passed_layout || self.class.default_layout(default_template_format)
+      layout = passed_layout || default_layout
+      return layout if layout.respond_to?(:render)
 
       active_layout = case layout
         when Symbol then __send__(layout)
         when Proc   then layout.call(self)
         else layout
       end
-
-      if active_layout
-        if layout = self.class.find_layout(active_layout, @template.template_format)
-          layout
-        else
-          raise ActionView::MissingTemplate.new(self.class.view_paths, active_layout)
-        end
-      end
+      
+      find_layout(active_layout, @template.template_format) if active_layout
     end
 
     private
-      def candidate_for_layout?(options)
-        template = options[:template] || default_template(options[:action])
-        if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
-          begin
-            !self.view_paths.find_template(template, default_template_format).exempt_from_layout?
-          rescue ActionView::MissingTemplate
-            true
-          end
-        end
+      def default_layout #:nodoc:
+        layout = self.class.read_inheritable_attribute(:layout) unless default_template_format == :js
+        return layout unless self.class.read_inheritable_attribute(:auto_layout)
+        find_layout(layout, default_template_format)
       rescue ActionView::MissingTemplate
-        false
+        nil
+      end
+
+      def find_layout(layout, *formats) #:nodoc:
+        view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", *formats)
       end
 
       def pick_layout(options)
@@ -273,6 +254,19 @@ module ActionController #:nodoc:
         end
       end
 
+      def candidate_for_layout?(options)
+        template = options[:template] || default_template(options[:action])
+        if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
+          begin
+            !self.view_paths.find_template(template, default_template_format).exempt_from_layout?
+          rescue ActionView::MissingTemplate
+            true
+          end
+        end
+      rescue ActionView::MissingTemplate
+        false
+      end
+
       def default_template_format
         response.template.template_format
       end
diff --git a/actionpack/lib/action_controller/middleware_stack.rb b/actionpack/lib/action_controller/middleware_stack.rb
index dbc2fda41e..b739a6d72d 100644
--- a/actionpack/lib/action_controller/middleware_stack.rb
+++ b/actionpack/lib/action_controller/middleware_stack.rb
@@ -27,7 +27,9 @@ module ActionController
       end
 
       def klass
-        if @klass.is_a?(Class)
+        if @klass.respond_to?(:call)
+          @klass.call
+        elsif @klass.is_a?(Class)
           @klass
         else
           @klass.to_s.constantize
@@ -37,6 +39,8 @@ module ActionController
       end
 
       def active?
+        return false unless klass
+
         if @conditional.respond_to?(:call)
           @conditional.call
         else
@@ -63,11 +67,17 @@ module ActionController
 
       def build(app)
         if block
-          klass.new(app, *args, &block)
+          klass.new(app, *build_args, &block)
         else
-          klass.new(app, *args)
+          klass.new(app, *build_args)
         end
       end
+
+      private
+
+        def build_args
+          Array(args).map { |arg| arg.respond_to?(:call) ? arg.call : arg }
+        end
     end
 
     def initialize(*args, &block)
diff --git a/actionpack/lib/action_controller/middlewares.rb b/actionpack/lib/action_controller/middlewares.rb
index 8ea1b5c7ce..371cf6d8f7 100644
--- a/actionpack/lib/action_controller/middlewares.rb
+++ b/actionpack/lib/action_controller/middlewares.rb
@@ -4,17 +4,8 @@ use "Rack::Lock", :if => lambda {
 
 use "ActionController::Failsafe"
 
-["ActionController::Session::CookieStore",
- "ActionController::Session::MemCacheStore",
- "ActiveRecord::SessionStore"].each do |store|
-   use(store, ActionController::Base.session_options,
-      :if => lambda {
-        if session_store = ActionController::Base.session_store
-          session_store.name == store
-        end
-      }
-    )
-end
+use lambda { ActionController::Base.session_store },
+    lambda { ActionController::Base.session_options }
 
 use "ActionController::RewindableInput"
 use "ActionController::ParamsParser"
diff --git a/actionpack/lib/action_controller/reloader.rb b/actionpack/lib/action_controller/reloader.rb
new file mode 100644
index 0000000000..46789309cd
--- /dev/null
+++ b/actionpack/lib/action_controller/reloader.rb
@@ -0,0 +1,14 @@
+module ActionController
+  class Reloader
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Dispatcher.reload_application
+      @app.call(env)
+    ensure
+      Dispatcher.cleanup_application
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/routing/segments.rb b/actionpack/lib/action_controller/routing/segments.rb
index 5dda3d4d00..129e87c139 100644
--- a/actionpack/lib/action_controller/routing/segments.rb
+++ b/actionpack/lib/action_controller/routing/segments.rb
@@ -191,23 +191,19 @@ module ActionController
       end
 
       def regexp_chunk
-        if regexp
-          if regexp_has_modifiers?
-            "(#{regexp.to_s})"
-          else
-            "(#{regexp.source})"
-          end
-        else
-          "([^#{Routing::SEPARATORS.join}]+)"
-        end
+        regexp ? regexp_string : default_regexp_chunk
+      end
+
+      def regexp_string
+        regexp_has_modifiers? ? "(#{regexp.to_s})" : "(#{regexp.source})"
+      end
+
+      def default_regexp_chunk
+        "([^#{Routing::SEPARATORS.join}]+)"
       end
 
       def number_of_captures
-        if regexp
-          regexp.number_of_captures + 1
-        else
-          1
-        end
+        regexp ? regexp.number_of_captures + 1 : 1
       end
 
       def build_pattern(pattern)
@@ -244,10 +240,6 @@ module ActionController
         "(?i-:(#{(regexp || Regexp.union(*possible_names)).source}))"
       end
 
-      def number_of_captures
-        1
-      end
-
       # Don't URI.escape the controller name since it may contain slashes.
       def interpolation_chunk(value_code = local_name)
         "\#{#{value_code}.to_s}"
@@ -289,8 +281,8 @@ module ActionController
         "params[:#{key}] = PathSegment::Result.new_escaped((match[#{next_capture}]#{" || " + default.inspect if default}).split('/'))#{" if match[" + next_capture + "]" if !default}"
       end
 
-      def regexp_chunk
-        regexp || "(.*)"
+      def default_regexp_chunk
+        "(.*)"
       end
 
       def number_of_captures