Merge branch 'master' into active_model

Conflicts:
	activeresource/lib/active_resource/validations.rb

245 files changed, 5151 insertions, 2947 deletions

diff --git a/actionpack/CHANGELOG b/actionpack/CHANGELOG
index 8c9486cc63..204f5ae272 100644
--- a/actionpack/CHANGELOG
+++ b/actionpack/CHANGELOG
@@ -1,7 +1,14 @@
+*Edge*
+
+* Fixed that TestResponse.cookies was returning cookies unescaped #1867 [Doug McInnes]
+
+
 *2.3.2 [Final] (March 15, 2009)*
 
 * Fixed that redirection would just log the options, not the final url (which lead to "Redirected to #<Post:0x23150b8>") [DHH]
 
+* Don't check authenticity tokens for any AJAX requests [Ross Kaffenberger/Bryan Helmkamp]
+
 * Added ability to pass in :public => true to fresh_when, stale?, and expires_in to make the request proxy cachable #2095 [Gregg Pollack]
 
 * Fixed that passing a custom form builder would be forwarded to nested fields_for calls #2023 [Eloy Duran/Nate Wiger]
diff --git a/actionpack/Rakefile b/actionpack/Rakefile
index 6cacdf3c6e..300c2ebf81 100644
--- a/actionpack/Rakefile
+++ b/actionpack/Rakefile
@@ -30,7 +30,7 @@ Rake::TestTask.new(:test_action_pack) do |t|
 
   # make sure we include the tests in alphabetical order as on some systems
   # this will not happen automatically and the tests (as a whole) will error
-  t.test_files = Dir.glob( "test/[cft]*/**/*_test.rb" ).sort
+  t.test_files = Dir.glob( "test/[cdft]*/**/*_test.rb" ).sort
 
   t.verbose = true
   #t.warning = true
diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index d03f4cb231..100a0be1db 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -31,86 +31,59 @@ rescue LoadError
   end
 end
 
-begin
-  gem 'rack', '~> 1.0.0'
-  require 'rack'
-rescue Gem::LoadError
-  require 'action_controller/vendor/rack-1.0/rack'
-end
+require File.join(File.dirname(__FILE__), "action_pack")
 
 module ActionController
   # TODO: Review explicit to see if they will automatically be handled by
   # the initilizer if they are really needed.
   def self.load_all!
-    [Base, CGIHandler, CgiRequest, Request, Response, Http::Headers, UrlRewriter, UrlWriter]
+    [Base, Request, Response, UrlRewriter, UrlWriter]
+    [ActionDispatch::Http::Headers]
   end
 
-  autoload :AbstractRequest, 'action_controller/request'
-  autoload :Base, 'action_controller/base'
-  autoload :Benchmarking, 'action_controller/benchmarking'
+  autoload :Base, 'action_controller/base/base'
+  autoload :Benchmarking, 'action_controller/base/chained/benchmarking'
   autoload :Caching, 'action_controller/caching'
-  autoload :Cookies, 'action_controller/cookies'
-  autoload :Dispatcher, 'action_controller/dispatcher'
-  autoload :Failsafe, 'action_controller/failsafe'
-  autoload :Filters, 'action_controller/filters'
-  autoload :Flash, 'action_controller/flash'
-  autoload :Helpers, 'action_controller/helpers'
-  autoload :HttpAuthentication, 'action_controller/http_authentication'
-  autoload :Integration, 'action_controller/integration'
-  autoload :IntegrationTest, 'action_controller/integration'
-  autoload :Layout, 'action_controller/layout'
-  autoload :MiddlewareStack, 'action_controller/middleware_stack'
-  autoload :MimeResponds, 'action_controller/mime_responds'
-  autoload :ParamsParser, 'action_controller/params_parser'
-  autoload :PolymorphicRoutes, 'action_controller/polymorphic_routes'
+  autoload :Cookies, 'action_controller/base/cookies'
+  autoload :Dispatcher, 'action_controller/dispatch/dispatcher'
+  autoload :Filters, 'action_controller/base/chained/filters'
+  autoload :Flash, 'action_controller/base/chained/flash'
+  autoload :Helpers, 'action_controller/base/helpers'
+  autoload :HttpAuthentication, 'action_controller/base/http_authentication'
+  autoload :Integration, 'action_controller/testing/integration'
+  autoload :IntegrationTest, 'action_controller/testing/integration'
+  autoload :Layout, 'action_controller/base/layout'
+  autoload :MimeResponds, 'action_controller/base/mime_responds'
+  autoload :PolymorphicRoutes, 'action_controller/routing/generation/polymorphic_routes'
   autoload :RecordIdentifier, 'action_controller/record_identifier'
-  autoload :Reloader, 'action_controller/reloader'
-  autoload :Request, 'action_controller/request'
-  autoload :RequestForgeryProtection, 'action_controller/request_forgery_protection'
-  autoload :Rescue, 'action_controller/rescue'
-  autoload :Resources, 'action_controller/resources'
-  autoload :Response, 'action_controller/response'
-  autoload :RewindableInput, 'action_controller/rewindable_input'
+  autoload :Redirector, 'action_controller/base/redirect'
+  autoload :Renderer, 'action_controller/base/render'
+  autoload :RequestForgeryProtection, 'action_controller/base/request_forgery_protection'
+  autoload :Rescue, 'action_controller/dispatch/rescue'
+  autoload :Resources, 'action_controller/routing/resources'
+  autoload :Responder, 'action_controller/base/responder'
   autoload :Routing, 'action_controller/routing'
-  autoload :SessionManagement, 'action_controller/session_management'
-  autoload :StatusCodes, 'action_controller/status_codes'
-  autoload :Streaming, 'action_controller/streaming'
-  autoload :TestCase, 'action_controller/test_case'
-  autoload :TestProcess, 'action_controller/test_process'
+  autoload :SessionManagement, 'action_controller/base/session_management'
+  autoload :Streaming, 'action_controller/base/streaming'
+  autoload :TestCase, 'action_controller/testing/test_case'
+  autoload :TestProcess, 'action_controller/testing/process'
   autoload :Translation, 'action_controller/translation'
-  autoload :UploadedFile, 'action_controller/uploaded_file'
-  autoload :UploadedStringIO, 'action_controller/uploaded_file'
-  autoload :UploadedTempfile, 'action_controller/uploaded_file'
-  autoload :UrlRewriter, 'action_controller/url_rewriter'
-  autoload :UrlWriter, 'action_controller/url_rewriter'
-  autoload :Verification, 'action_controller/verification'
+  autoload :UrlEncodedPairParser, 'action_controller/dispatch/url_encoded_pair_parser'
+  autoload :UrlRewriter, 'action_controller/routing/generation/url_rewriter'
+  autoload :UrlWriter, 'action_controller/routing/generation/url_rewriter'
+  autoload :Verification, 'action_controller/base/verification'
 
   module Assertions
-    autoload :DomAssertions, 'action_controller/assertions/dom_assertions'
-    autoload :ModelAssertions, 'action_controller/assertions/model_assertions'
-    autoload :ResponseAssertions, 'action_controller/assertions/response_assertions'
-    autoload :RoutingAssertions, 'action_controller/assertions/routing_assertions'
-    autoload :SelectorAssertions, 'action_controller/assertions/selector_assertions'
-    autoload :TagAssertions, 'action_controller/assertions/tag_assertions'
-  end
-
-  module Http
-    autoload :Headers, 'action_controller/headers'
+    autoload :DomAssertions, 'action_controller/testing/assertions/dom'
+    autoload :ModelAssertions, 'action_controller/testing/assertions/model'
+    autoload :ResponseAssertions, 'action_controller/testing/assertions/response'
+    autoload :RoutingAssertions, 'action_controller/testing/assertions/routing'
+    autoload :SelectorAssertions, 'action_controller/testing/assertions/selector'
+    autoload :TagAssertions, 'action_controller/testing/assertions/tag'
   end
-
-  module Session
-    autoload :AbstractStore, 'action_controller/session/abstract_store'
-    autoload :CookieStore, 'action_controller/session/cookie_store'
-    autoload :MemCacheStore, 'action_controller/session/mem_cache_store'
-  end
-
-  # DEPRECATE: Remove CGI support
-  autoload :CgiRequest, 'action_controller/cgi_process'
-  autoload :CGIHandler, 'action_controller/cgi_process'
 end
 
-autoload :Mime, 'action_controller/mime_type'
-
 autoload :HTML, 'action_controller/vendor/html-scanner'
 
+require 'action_dispatch'
 require 'action_view'
diff --git a/actionpack/lib/action_controller/abstract.rb b/actionpack/lib/action_controller/abstract.rb
new file mode 100644
index 0000000000..3f5c4a185f
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract.rb
@@ -0,0 +1,10 @@
+module AbstractController
+  autoload :Base,           "action_controller/abstract/base"
+  autoload :Callbacks,      "action_controller/abstract/callbacks"
+  autoload :Helpers,        "action_controller/abstract/helpers"
+  autoload :Layouts,        "action_controller/abstract/layouts"
+  autoload :Logger,         "action_controller/abstract/logger"
+  autoload :Renderer,       "action_controller/abstract/renderer"
+  # === Exceptions
+  autoload :ActionNotFound, "action_controller/abstract/exceptions"
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/base.rb b/actionpack/lib/action_controller/abstract/base.rb
new file mode 100644
index 0000000000..ade7719cc0
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/base.rb
@@ -0,0 +1,41 @@
+module AbstractController
+  class Base
+    
+    attr_internal :response_body
+    attr_internal :response_obj
+    attr_internal :action_name
+    
+    def self.process(action)
+      new.process(action)
+    end
+    
+    def self.inherited(klass)
+    end
+    
+    def initialize
+      self.response_obj = {}
+    end
+    
+    def process(action_name)
+      unless respond_to_action?(action_name)
+        raise ActionNotFound, "The action '#{action_name}' could not be found"
+      end
+      
+      @_action_name = action_name
+      process_action
+      self.response_obj[:body] = self.response_body
+      self
+    end
+    
+  private
+  
+    def process_action
+      respond_to?(action_name) ? send(action_name) : send(:action_missing, action_name)
+    end
+    
+    def respond_to_action?(action_name)
+      respond_to?(action_name) || respond_to?(:action_missing, true)
+    end
+    
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/callbacks.rb b/actionpack/lib/action_controller/abstract/callbacks.rb
new file mode 100644
index 0000000000..c8b509081c
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/callbacks.rb
@@ -0,0 +1,40 @@
+module AbstractController
+  module Callbacks
+    setup do
+      include ActiveSupport::NewCallbacks
+      define_callbacks :process_action      
+    end
+    
+    def process_action
+      _run_process_action_callbacks(action_name) do
+        super
+      end
+    end
+    
+    module ClassMethods
+      def _normalize_callback_options(options)
+        if only = options[:only]
+          only = Array(only).map {|o| "action_name == :#{o}"}.join(" || ")
+          options[:per_key] = {:if => only}
+        end
+        if except = options[:except]
+          except = Array(except).map {|e| "action_name == :#{e}"}.join(" || ")          
+          options[:per_key] = {:unless => except}
+        end
+      end
+      
+      [:before, :after, :around].each do |filter|
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def #{filter}_filter(*names, &blk)
+            options = names.last.is_a?(Hash) ? names.pop : {}
+            _normalize_callback_options(options)
+            names.push(blk) if block_given?
+            names.each do |name|
+              process_action_callback(:#{filter}, name, options)
+            end
+          end
+        RUBY_EVAL
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/exceptions.rb b/actionpack/lib/action_controller/abstract/exceptions.rb
new file mode 100644
index 0000000000..ec4680629b
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/exceptions.rb
@@ -0,0 +1,3 @@
+module AbstractController
+  class ActionNotFound < StandardError ; end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/helpers.rb b/actionpack/lib/action_controller/abstract/helpers.rb
new file mode 100644
index 0000000000..1f0b38417b
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/helpers.rb
@@ -0,0 +1,59 @@
+module AbstractController
+  module Helpers
+    depends_on Renderer
+    
+    setup do
+      extlib_inheritable_accessor :master_helper_module
+      self.master_helper_module = Module.new
+    end
+  
+    # def self.included(klass)
+    #   klass.class_eval do
+    #     extlib_inheritable_accessor :master_helper_module
+    #     self.master_helper_module = Module.new
+    #   end
+    # end
+    
+    def _action_view
+      @_action_view ||= begin
+        av = super
+        av.helpers.send(:include, master_helper_module)
+        av
+      end
+    end
+    
+    module ClassMethods
+      def inherited(klass)
+        klass.master_helper_module = Module.new
+        klass.master_helper_module.__send__ :include, master_helper_module
+        
+        super
+      end
+      
+      def add_template_helper(mod)
+        master_helper_module.module_eval { include mod }
+      end
+      
+      def helper_method(*meths)
+        meths.flatten.each do |meth|
+          master_helper_module.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+            def #{meth}(*args, &blk)
+              controller.send(%(#{meth}), *args, &blk)
+            end
+          ruby_eval
+        end
+      end
+      
+      def helper(*args, &blk)
+        args.flatten.each do |arg|
+          case arg
+          when Module
+            add_template_helper(arg)
+          end
+        end
+        master_helper_module.module_eval(&blk) if block_given?
+      end
+    end
+    
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/layouts.rb b/actionpack/lib/action_controller/abstract/layouts.rb
new file mode 100644
index 0000000000..478b301a26
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/layouts.rb
@@ -0,0 +1,82 @@
+module AbstractController
+  module Layouts
+    
+    depends_on Renderer
+        
+    module ClassMethods
+      def layout(layout)
+        unless [String, Symbol, FalseClass, NilClass].include?(layout.class)
+          raise ArgumentError, "Layouts must be specified as a String, Symbol, false, or nil"
+        end
+        
+        @_layout = layout || false # Converts nil to false
+        _write_layout_method
+      end
+      
+      def _implied_layout_name
+        name.underscore
+      end
+      
+      # Takes the specified layout and creates a _layout method to be called
+      # by _default_layout
+      # 
+      # If the specified layout is a:
+      # String:: return the string
+      # Symbol:: call the method specified by the symbol
+      # false::  return nil
+      # none::   If a layout is found in the view paths with the controller's
+      #          name, return that string. Otherwise, use the superclass'
+      #          layout (which might also be implied)
+      def _write_layout_method
+        case @_layout
+        when String
+          self.class_eval %{def _layout() #{@_layout.inspect} end}
+        when Symbol
+          self.class_eval %{def _layout() #{@_layout} end}
+        when false
+          self.class_eval %{def _layout() end}
+        else
+          self.class_eval %{
+            def _layout
+              if view_paths.find_by_parts?("#{_implied_layout_name}", formats, "layouts")
+                "#{_implied_layout_name}"
+              else
+                super
+              end
+            end
+          }
+        end
+      end
+    end
+    
+    def _render_template(template, options)
+      _action_view._render_template_with_layout(template, options[:_layout])
+    end
+        
+  private
+  
+    def _layout() end # This will be overwritten
+    
+    def _layout_for_name(name)
+      unless [String, FalseClass, NilClass].include?(name.class)
+        raise ArgumentError, "String, false, or nil expected; you passed #{name.inspect}"
+      end
+      
+      name && view_paths.find_by_parts(name, formats, "layouts")
+    end
+    
+    def _default_layout(require_layout = false)
+      if require_layout && !_layout
+        raise ArgumentError, 
+          "There was no default layout for #{self.class} in #{view_paths.inspect}"
+      end
+        
+      begin
+        layout = _layout_for_name(_layout)
+      rescue NameError => e
+        raise NoMethodError, 
+          "You specified #{@_layout.inspect} as the layout, but no such method was found"
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/logger.rb b/actionpack/lib/action_controller/abstract/logger.rb
new file mode 100644
index 0000000000..4117369bd4
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/logger.rb
@@ -0,0 +1,7 @@
+module AbstractController
+  module Logger
+    setup do
+      cattr_accessor :logger
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/renderer.rb b/actionpack/lib/action_controller/abstract/renderer.rb
new file mode 100644
index 0000000000..a86eef889e
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/renderer.rb
@@ -0,0 +1,80 @@
+require "action_controller/abstract/logger"
+
+module AbstractController
+  module Renderer
+    depends_on AbstractController::Logger
+    
+    setup do
+      attr_internal :formats
+      
+      extlib_inheritable_accessor :_view_paths
+      
+      self._view_paths ||= ActionView::PathSet.new
+    end
+        
+    def _action_view
+      @_action_view ||= ActionView::Base.new(self.class.view_paths, {}, self)      
+    end
+        
+    def render(options = {})
+      self.response_body = render_to_body(options)
+    end
+    
+    # Raw rendering of a template to a Rack-compatible body.
+    # ====
+    # @option _prefix<String> The template's path prefix
+    # @option _layout<String> The relative path to the layout template to use
+    # 
+    # :api: plugin
+    def render_to_body(options = {})
+      name = options[:_template_name] || action_name
+      
+      template = options[:_template] || view_paths.find_by_parts(name.to_s, formats, options[:_prefix])
+      _render_template(template, options)
+    end
+
+    # Raw rendering of a template to a string.
+    # ====
+    # @option _prefix<String> The template's path prefix
+    # @option _layout<String> The relative path to the layout template to use
+    # 
+    # :api: plugin
+    def render_to_string(options = {})
+      AbstractController::Renderer.body_to_s(render_to_body(options))
+    end
+
+    def _render_template(template, options)
+      _action_view._render_template_with_layout(template)
+    end
+    
+    def view_paths() _view_paths end
+
+    # Return a string representation of a Rack-compatible response body.
+    def self.body_to_s(body)
+      if body.respond_to?(:to_str)
+        body
+      else
+        strings = []
+        body.each { |part| strings << part.to_s }
+        body.close if body.respond_to?(:close)
+        strings.join
+      end
+    end
+
+    module ClassMethods
+      
+      def append_view_path(path)
+        self.view_paths << path
+      end
+      
+      def view_paths
+        self._view_paths
+      end
+      
+      def view_paths=(paths)
+        self._view_paths = paths.is_a?(ActionView::PathSet) ?
+                            paths : ActionView::Base.process_view_paths(paths)
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/base.rb b/actionpack/lib/action_controller/base/base.rb
index c6dd99e959..3000b3d12f 100644
--- a/actionpack/lib/action_controller/base.rb
+++ b/actionpack/lib/action_controller/base/base.rb
@@ -1,3 +1,4 @@
+require 'action_controller/deprecated'
 require 'set'
 
 module ActionController #:nodoc:
@@ -58,22 +59,6 @@ module ActionController #:nodoc:
     end
   end
 
-  class DoubleRenderError < ActionControllerError #:nodoc:
-    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
-
-    def initialize(message = nil)
-      super(message || DEFAULT_MESSAGE)
-    end
-  end
-
-  class RedirectBackError < ActionControllerError #:nodoc:
-    DEFAULT_MESSAGE = 'No HTTP_REFERER was set in the request to this action, so redirect_to :back could not be called successfully. If this is a test, make sure to specify request.env["HTTP_REFERER"].'
-
-    def initialize(message = nil)
-      super(message || DEFAULT_MESSAGE)
-    end
-  end
-
   class UnknownHttpMethod < ActionControllerError #:nodoc:
   end
 
@@ -247,9 +232,8 @@ module ActionController #:nodoc:
   #   end
   #
   class Base
-    DEFAULT_RENDER_STATUS_CODE = "200 OK"
 
-    include StatusCodes
+    include ActionDispatch::StatusCodes
 
     cattr_reader :protected_instance_variables
     # Controller specific instance variables which will not be accessible inside views.
@@ -301,7 +285,10 @@ module ActionController #:nodoc:
     # A YAML parser is also available and can be turned on with:
     #
     #   ActionController::Base.param_parsers[Mime::YAML] = :yaml
-    @@param_parsers = {}
+    @@param_parsers = { Mime::MULTIPART_FORM   => :multipart_form,
+                        Mime::URL_ENCODED_FORM => :url_encoded_form,
+                        Mime::XML              => :xml_simple,
+                        Mime::JSON             => :json }
     cattr_accessor :param_parsers
 
     # Controls the default charset for all renders.
@@ -381,8 +368,8 @@ module ActionController #:nodoc:
     class << self
       def call(env)
         # HACK: For global rescue to have access to the original request and response
-        request = env["action_controller.rescue.request"] ||= Request.new(env)
-        response = env["action_controller.rescue.response"] ||= Response.new
+        request = env["action_controller.rescue.request"] ||= ActionDispatch::Request.new(env)
+        response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
         process(request, response)
       end
 
@@ -408,7 +395,7 @@ module ActionController #:nodoc:
 
       # Return an array containing the names of public methods that have been marked hidden from the action processor.
       # By default, all methods defined in ActionController::Base and included modules are hidden.
-      # More methods can be hidden using <tt>hide_actions</tt>.
+      # More methods can be hidden using <tt>hide_action</tt>.
       def hidden_actions
         read_inheritable_attribute(:hidden_actions) || write_inheritable_attribute(:hidden_actions, [])
       end
@@ -514,8 +501,8 @@ module ActionController #:nodoc:
       def process(request, response, method = :perform_action, *arguments) #:nodoc:
         response.request = request
 
-        initialize_template_class(response)
         assign_shortcuts(request, response)
+        initialize_template_class(response)
         initialize_current_url
         assign_names
 
@@ -678,371 +665,6 @@ module ActionController #:nodoc:
         @template.view_paths.push(*path)
       end
 
-    protected
-      # Renders the content that will be returned to the browser as the response body.
-      #
-      # === Rendering an action
-      #
-      # Action rendering is the most common form and the type used automatically by Action Controller when nothing else is
-      # specified. By default, actions are rendered within the current layout (if one exists).
-      #
-      #   # Renders the template for the action "goal" within the current controller
-      #   render :action => "goal"
-      #
-      #   # Renders the template for the action "short_goal" within the current controller,
-      #   # but without the current active layout
-      #   render :action => "short_goal", :layout => false
-      #
-      #   # Renders the template for the action "long_goal" within the current controller,
-      #   # but with a custom layout
-      #   render :action => "long_goal", :layout => "spectacular"
-      #
-      # === Rendering partials
-      #
-      # Partial rendering in a controller is most commonly used together with Ajax calls that only update one or a few elements on a page
-      # without reloading. Rendering of partials from the controller makes it possible to use the same partial template in
-      # both the full-page rendering (by calling it from within the template) and when sub-page updates happen (from the
-      # controller action responding to Ajax calls). By default, the current layout is not used.
-      #
-      #   # Renders the same partial with a local variable.
-      #   render :partial => "person", :locals => { :name => "david" }
-      #
-      #   # Renders the partial, making @new_person available through
-      #   # the local variable 'person'
-      #   render :partial => "person", :object => @new_person
-      #
-      #   # Renders a collection of the same partial by making each element
-      #   # of @winners available through the local variable "person" as it
-      #   # builds the complete response.
-      #   render :partial => "person", :collection => @winners
-      #
-      #   # Renders a collection of partials but with a custom local variable name
-      #   render :partial => "admin_person", :collection => @winners, :as => :person
-      #
-      #   # Renders the same collection of partials, but also renders the
-      #   # person_divider partial between each person partial.
-      #   render :partial => "person", :collection => @winners, :spacer_template => "person_divider"
-      #
-      #   # Renders a collection of partials located in a view subfolder
-      #   # outside of our current controller.  In this example we will be
-      #   # rendering app/views/shared/_note.r(html|xml)  Inside the partial
-      #   # each element of @new_notes is available as the local var "note".
-      #   render :partial => "shared/note", :collection => @new_notes
-      #
-      #   # Renders the partial with a status code of 500 (internal error).
-      #   render :partial => "broken", :status => 500
-      #
-      # Note that the partial filename must also be a valid Ruby variable name,
-      # so e.g. 2005 and register-user are invalid.
-      #
-      #
-      # == Automatic etagging
-      #
-      # Rendering will automatically insert the etag header on 200 OK responses. The etag is calculated using MD5 of the
-      # response body. If a request comes in that has a matching etag, the response will be changed to a 304 Not Modified
-      # and the response body will be set to an empty string. No etag header will be inserted if it's already set.
-      #
-      # === Rendering a template
-      #
-      # Template rendering works just like action rendering except that it takes a path relative to the template root.
-      # The current layout is automatically applied.
-      #
-      #   # Renders the template located in [TEMPLATE_ROOT]/weblog/show.r(html|xml) (in Rails, app/views/weblog/show.erb)
-      #   render :template => "weblog/show"
-      #
-      #   # Renders the template with a local variable
-      #   render :template => "weblog/show", :locals => {:customer => Customer.new}
-      #
-      # === Rendering a file
-      #
-      # File rendering works just like action rendering except that it takes a filesystem path. By default, the path
-      # is assumed to be absolute, and the current layout is not applied.
-      #
-      #   # Renders the template located at the absolute filesystem path
-      #   render :file => "/path/to/some/template.erb"
-      #   render :file => "c:/path/to/some/template.erb"
-      #
-      #   # Renders a template within the current layout, and with a 404 status code
-      #   render :file => "/path/to/some/template.erb", :layout => true, :status => 404
-      #   render :file => "c:/path/to/some/template.erb", :layout => true, :status => 404
-      #
-      # === Rendering text
-      #
-      # Rendering of text is usually used for tests or for rendering prepared content, such as a cache. By default, text
-      # rendering is not done within the active layout.
-      #
-      #   # Renders the clear text "hello world" with status code 200
-      #   render :text => "hello world!"
-      #
-      #   # Renders the clear text "Explosion!"  with status code 500
-      #   render :text => "Explosion!", :status => 500
-      #
-      #   # Renders the clear text "Hi there!" within the current active layout (if one exists)
-      #   render :text => "Hi there!", :layout => true
-      #
-      #   # Renders the clear text "Hi there!" within the layout
-      #   # placed in "app/views/layouts/special.r(html|xml)"
-      #   render :text => "Hi there!", :layout => "special"
-      #
-      # === Streaming data and/or controlling the page generation
-      #
-      # The <tt>:text</tt> option can also accept a Proc object, which can be used to:
-      #
-      # 1. stream on-the-fly generated data to the browser. Note that you should
-      #    use the methods provided by ActionController::Steaming instead if you
-      #    want to stream a buffer or a file.
-      # 2. manually control the page generation. This should generally be avoided,
-      #    as it violates the separation between code and content, and because almost
-      #    everything that can be done with this method can also be done more cleanly
-      #    using one of the other rendering methods, most notably templates.
-      #
-      # Two arguments are passed to the proc, a <tt>response</tt> object and an
-      # <tt>output</tt> object. The response object is equivalent to the return
-      # value of the ActionController::Base#response method, and can be used to
-      # control various things in the HTTP response, such as setting the
-      # Content-Type header. The output object is an writable <tt>IO</tt>-like
-      # object, so one can call <tt>write</tt> and <tt>flush</tt> on it.
-      #
-      # The following example demonstrates how one can stream a large amount of
-      # on-the-fly generated data to the browser:
-      #
-      #   # Streams about 180 MB of generated data to the browser.
-      #   render :text => proc { |response, output|
-      #     10_000_000.times do |i|
-      #       output.write("This is line #{i}\n")
-      #       output.flush
-      #     end
-      #   }
-      #
-      # Another example:
-      #
-      #   # Renders "Hello from code!"
-      #   render :text => proc { |response, output| output.write("Hello from code!") }
-      #
-      # === Rendering XML
-      #
-      # Rendering XML sets the content type to application/xml.
-      #
-      #   # Renders '<name>David</name>'
-      #   render :xml => {:name => "David"}.to_xml
-      #
-      # It's not necessary to call <tt>to_xml</tt> on the object you want to render, since <tt>render</tt> will
-      # automatically do that for you:
-      #
-      #   # Also renders '<name>David</name>'
-      #   render :xml => {:name => "David"}
-      #
-      # === Rendering JSON
-      #
-      # Rendering JSON sets the content type to application/json and optionally wraps the JSON in a callback. It is expected
-      # that the response will be parsed (or eval'd) for use as a data structure.
-      #
-      #   # Renders '{"name": "David"}'
-      #   render :json => {:name => "David"}.to_json
-      #
-      # It's not necessary to call <tt>to_json</tt> on the object you want to render, since <tt>render</tt> will
-      # automatically do that for you:
-      #
-      #   # Also renders '{"name": "David"}'
-      #   render :json => {:name => "David"}
-      #
-      # Sometimes the result isn't handled directly by a script (such as when the request comes from a SCRIPT tag),
-      # so the <tt>:callback</tt> option is provided for these cases.
-      #
-      #   # Renders 'show({"name": "David"})'
-      #   render :json => {:name => "David"}.to_json, :callback => 'show'
-      #
-      # === Rendering an inline template
-      #
-      # Rendering of an inline template works as a cross between text and action rendering where the source for the template
-      # is supplied inline, like text, but its interpreted with ERb or Builder, like action. By default, ERb is used for rendering
-      # and the current layout is not used.
-      #
-      #   # Renders "hello, hello, hello, again"
-      #   render :inline => "<%= 'hello, ' * 3 + 'again' %>"
-      #
-      #   # Renders "<p>Good seeing you!</p>" using Builder
-      #   render :inline => "xml.p { 'Good seeing you!' }", :type => :builder
-      #
-      #   # Renders "hello david"
-      #   render :inline => "<%= 'hello ' + name %>", :locals => { :name => "david" }
-      #
-      # === Rendering inline JavaScriptGenerator page updates
-      #
-      # In addition to rendering JavaScriptGenerator page updates with Ajax in RJS templates (see ActionView::Base for details),
-      # you can also pass the <tt>:update</tt> parameter to +render+, along with a block, to render page updates inline.
-      #
-      #   render :update do |page|
-      #     page.replace_html  'user_list', :partial => 'user', :collection => @users
-      #     page.visual_effect :highlight, 'user_list'
-      #   end
-      #
-      # === Rendering vanilla JavaScript
-      #
-      # In addition to using RJS with render :update, you can also just render vanilla JavaScript with :js.
-      #
-      #   # Renders "alert('hello')" and sets the mime type to text/javascript
-      #   render :js => "alert('hello')"
-      #
-      # === Rendering with status and location headers
-      # All renders take the <tt>:status</tt> and <tt>:location</tt> options and turn them into headers. They can even be used together:
-      #
-      #   render :xml => post.to_xml, :status => :created, :location => post_url(post)
-      def render(options = nil, extra_options = {}, &block) #:doc:
-        raise DoubleRenderError, "Can only render or redirect once per action" if performed?
-
-        validate_render_arguments(options, extra_options, block_given?)
-
-        if options.nil?
-          options = { :template => default_template, :layout => true }
-        elsif options == :update
-          options = extra_options.merge({ :update => true })
-        elsif options.is_a?(String) || options.is_a?(Symbol)
-          case options.to_s.index('/')
-          when 0
-            extra_options[:file] = options
-          when nil
-            extra_options[:action] = options
-          else
-            extra_options[:template] = options
-          end
-
-          options = extra_options
-        elsif !options.is_a?(Hash)
-          extra_options[:partial] = options
-          options = extra_options
-        end
-
-        layout = pick_layout(options)
-        response.layout = layout.path_without_format_and_extension if layout
-        logger.info("Rendering template within #{layout.path_without_format_and_extension}") if logger && layout
-
-        if content_type = options[:content_type]
-          response.content_type = content_type.to_s
-        end
-
-        if location = options[:location]
-          response.headers["Location"] = url_for(location)
-        end
-
-        if options.has_key?(:text)
-          text = layout ? @template.render(options.merge(:text => options[:text], :layout => layout)) : options[:text]
-          render_for_text(text, options[:status])
-
-        else
-          if file = options[:file]
-            render_for_file(file, options[:status], layout, options[:locals] || {})
-
-          elsif template = options[:template]
-            render_for_file(template, options[:status], layout, options[:locals] || {})
-
-          elsif inline = options[:inline]
-            render_for_text(@template.render(options.merge(:layout => layout)), options[:status])
-
-          elsif action_name = options[:action]
-            render_for_file(default_template(action_name.to_s), options[:status], layout)
-
-          elsif xml = options[:xml]
-            response.content_type ||= Mime::XML
-            render_for_text(xml.respond_to?(:to_xml) ? xml.to_xml : xml, options[:status])
-
-          elsif js = options[:js]
-            response.content_type ||= Mime::JS
-            render_for_text(js, options[:status])
-
-          elsif json = options[:json]
-            json = json.to_json unless json.is_a?(String)
-            json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
-            response.content_type ||= Mime::JSON
-            render_for_text(json, options[:status])
-
-          elsif options[:partial]
-            options[:partial] = default_template_name if options[:partial] == true
-            if layout
-              render_for_text(@template.render(:text => @template.render(options), :layout => layout), options[:status])
-            else
-              render_for_text(@template.render(options), options[:status])
-            end
-
-          elsif options[:update]
-            @template.send(:_evaluate_assigns_and_ivars)
-
-            generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template, &block)
-            response.content_type = Mime::JS
-            render_for_text(generator.to_s, options[:status])
-
-          elsif options[:nothing]
-            render_for_text(nil, options[:status])
-
-          else
-            render_for_file(default_template, options[:status], layout)
-          end
-        end
-      end
-
-      # Renders according to the same rules as <tt>render</tt>, but returns the result in a string instead
-      # of sending it as the response body to the browser.
-      def render_to_string(options = nil, &block) #:doc:
-        render(options, &block)
-        response.body
-      ensure
-        response.content_type = nil
-        erase_render_results
-        reset_variables_added_to_assigns
-      end
-
-      # Return a response that has no content (merely headers). The options
-      # argument is interpreted to be a hash of header names and values.
-      # This allows you to easily return a response that consists only of
-      # significant headers:
-      #
-      #   head :created, :location => person_path(@person)
-      #
-      # It can also be used to return exceptional conditions:
-      #
-      #   return head(:method_not_allowed) unless request.post?
-      #   return head(:bad_request) unless valid_request?
-      #   render
-      def head(*args)
-        if args.length > 2
-          raise ArgumentError, "too many arguments to head"
-        elsif args.empty?
-          raise ArgumentError, "too few arguments to head"
-        end
-        options = args.extract_options!
-        status = interpret_status(args.shift || options.delete(:status) || :ok)
-
-        options.each do |key, value|
-          headers[key.to_s.dasherize.split(/-/).map { |v| v.capitalize }.join("-")] = value.to_s
-        end
-
-        render :nothing => true, :status => status
-      end
-
-      # Clears the rendered results, allowing for another render to be performed.
-      def erase_render_results #:nodoc:
-        response.body = []
-        @performed_render = false
-      end
-
-      # Clears the redirected results from the headers, resets the status to 200 and returns
-      # the URL that was used to redirect or nil if there was no redirected URL
-      # Note that +redirect_to+ will change the body of the response to indicate a redirection.
-      # The response body is not reset here, see +erase_render_results+
-      def erase_redirect_results #:nodoc:
-        @performed_redirect = false
-        response.redirected_to = nil
-        response.redirected_to_method_params = nil
-        response.status = DEFAULT_RENDER_STATUS_CODE
-        response.headers.delete('Location')
-      end
-
-      # Erase both render and redirect results
-      def erase_results #:nodoc:
-        erase_render_results
-        erase_redirect_results
-      end
-
       def rewrite_options(options) #:nodoc:
         if defaults = default_url_options(options)
           defaults.merge(options)
@@ -1064,73 +686,6 @@ module ActionController #:nodoc:
       def default_url_options(options = nil)
       end
 
-      # Redirects the browser to the target specified in +options+. This parameter can take one of three forms:
-      #
-      # * <tt>Hash</tt> - The URL will be generated by calling url_for with the +options+.
-      # * <tt>Record</tt> - The URL will be generated by calling url_for with the +options+, which will reference a named URL for that record.
-      # * <tt>String</tt> starting with <tt>protocol://</tt> (like <tt>http://</tt>) - Is passed straight through as the target for redirection.
-      # * <tt>String</tt> not containing a protocol - The current protocol and host is prepended to the string.
-      # * <tt>:back</tt> - Back to the page that issued the request. Useful for forms that are triggered from multiple places.
-      #   Short-hand for <tt>redirect_to(request.env["HTTP_REFERER"])</tt>
-      #
-      # Examples:
-      #   redirect_to :action => "show", :id => 5
-      #   redirect_to post
-      #   redirect_to "http://www.rubyonrails.org"
-      #   redirect_to "/images/screenshot.jpg"
-      #   redirect_to articles_url
-      #   redirect_to :back
-      #
-      # The redirection happens as a "302 Moved" header unless otherwise specified.
-      #
-      # Examples:
-      #   redirect_to post_url(@post), :status=>:found
-      #   redirect_to :action=>'atom', :status=>:moved_permanently
-      #   redirect_to post_url(@post), :status=>301
-      #   redirect_to :action=>'atom', :status=>302
-      #
-      # When using <tt>redirect_to :back</tt>, if there is no referrer,
-      # RedirectBackError will be raised. You may specify some fallback
-      # behavior for this case by rescuing RedirectBackError.
-      def redirect_to(options = {}, response_status = {}) #:doc:
-        raise ActionControllerError.new("Cannot redirect to nil!") if options.nil?
-
-        if options.is_a?(Hash) && options[:status]
-          status = options.delete(:status)
-        elsif response_status[:status]
-          status = response_status[:status]
-        else
-          status = 302
-        end
-
-        response.redirected_to = options
-
-        case options
-          # The scheme name consist of a letter followed by any combination of
-          # letters, digits, and the plus ("+"), period ("."), or hyphen ("-")
-          # characters; and is terminated by a colon (":").
-          when %r{^\w[\w\d+.-]*:.*}
-            redirect_to_full_url(options, status)
-          when String
-            redirect_to_full_url(request.protocol + request.host_with_port + options, status)
-          when :back
-            if referer = request.headers["Referer"]
-              redirect_to(referer, :status=>status)
-            else
-              raise RedirectBackError
-            end
-          else
-            redirect_to_full_url(url_for(options), status)
-        end
-      end
-
-      def redirect_to_full_url(url, status)
-        raise DoubleRenderError if performed?
-        logger.info("Redirected to #{url}") if logger && logger.info?
-        response.redirect(url, interpret_status(status))
-        @performed_redirect = true
-      end
-
       # Sets the etag and/or last_modified on the response and checks it against
       # the client request. If the request doesn't match the options provided, the
       # request is considered stale and should be generated from scratch. Otherwise,
@@ -1236,40 +791,20 @@ module ActionController #:nodoc:
       end
 
     private
-      def render_for_file(template_path, status = nil, layout = nil, locals = {}) #:nodoc:
-        path = template_path.respond_to?(:path_without_format_and_extension) ? template_path.path_without_format_and_extension : template_path
-        logger.info("Rendering #{path}" + (status ? " (#{status})" : '')) if logger
-        render_for_text @template.render(:file => template_path, :locals => locals, :layout => layout), status
-      end
-
-      def render_for_text(text = nil, status = nil, append_response = false) #:nodoc:
-        @performed_render = true
-
-        response.status = interpret_status(status || DEFAULT_RENDER_STATUS_CODE)
-
-        if append_response
-          response.body_parts << text.to_s
-        else
-          response.body = case text
-            when Proc then  text
-            when nil  then  [" "] # Safari doesn't pass the headers of the return if the response is zero length
-            else            [text.to_s]
-          end
+      def _process_options(options)
+        if content_type = options[:content_type]
+          response.content_type = content_type.to_s
         end
-      end
 
-      def validate_render_arguments(options, extra_options, has_block)
-        if options && (has_block && options != :update) && !options.is_a?(String) && !options.is_a?(Hash) && !options.is_a?(Symbol)
-          raise RenderError, "You called render with invalid options : #{options.inspect}"
+        if location = options[:location]
+          response.headers["Location"] = url_for(location)
         end
 
-        if !extra_options.is_a?(Hash)
-          raise RenderError, "You called render with invalid options : #{options.inspect}, #{extra_options.inspect}"
-        end
+        response.status = interpret_status(options[:status] || DEFAULT_RENDER_STATUS_CODE)
       end
 
       def initialize_template_class(response)
-        response.template = ActionView::Base.new(self.class.view_paths, {}, self)
+        @template = response.template = ActionView::Base.new(self.class.view_paths, {}, self, formats)
         response.template.helpers.send :include, self.class.master_helper_module
         response.redirected_to = nil
         @performed_render = @performed_redirect = false
@@ -1282,7 +817,6 @@ module ActionController #:nodoc:
         @_response.session = request.session
 
         @_session = @_response.session
-        @template = @_response.template
 
         @_headers = @_response.headers
       end
@@ -1318,26 +852,25 @@ module ActionController #:nodoc:
       end
 
       def perform_action
-        if action_methods.include?(action_name)
-          send(action_name)
-          default_render unless performed?
-        elsif respond_to? :method_missing
-          method_missing action_name
-          default_render unless performed?
-        else
-          begin
-            default_render
-          rescue ActionView::MissingTemplate => e
-            # Was the implicit template missing, or was it another template?
-            if e.path == default_template_name
-              raise UnknownAction, "No action responded to #{action_name}. Actions: #{action_methods.sort.to_sentence(:locale => :en)}", caller
-            else
-              raise e
-            end
-          end
+        if called = action_methods.include?(action_name)
+          ret = send(action_name)
+        elsif called = respond_to?(:method_missing)
+          ret = method_missing(action_name)
+        end
+        
+        return (performed? ? ret : default_render) if called
+        
+        begin
+          default_render
+        rescue ActionView::MissingTemplate => e
+          raise e unless e.action_name == action_name
+          # If the path is the same as the action_name, the action is completely missing
+          raise UnknownAction, "No action responded to #{action_name}. Actions: " +
+            "#{action_methods.sort.to_sentence}", caller
         end
       end
 
+      # Returns true if a render or redirect has already been performed.
       def performed?
         @performed_render || @performed_redirect
       end
@@ -1346,22 +879,6 @@ module ActionController #:nodoc:
         @action_name = (params['action'] || 'index')
       end
 
-      def action_methods
-        self.class.action_methods
-      end
-
-      def self.action_methods
-        @action_methods ||=
-          # All public instance methods of this class, including ancestors
-          public_instance_methods(true).map { |m| m.to_s }.to_set -
-          # Except for public instance methods of Base and its ancestors
-          Base.public_instance_methods(true).map { |m| m.to_s } +
-          # Be sure to include shadowed public instance methods of this class
-          public_instance_methods(false).map { |m| m.to_s } -
-          # And always exclude explicitly hidden actions
-          hidden_actions
-      end
-
       def reset_variables_added_to_assigns
         @template.instance_variable_set("@assigns_added", nil)
       end
@@ -1372,10 +889,15 @@ module ActionController #:nodoc:
         @request_origin ||= "#{request.remote_ip} at #{Time.now.to_s(:db)}"
       end
 
+      # Returns the request URI used to get to the current location
       def complete_request_uri
         "#{request.protocol}#{request.host}#{request.request_uri}"
       end
 
+      def close_session
+        # @_session.close if @_session && @_session.respond_to?(:close)
+      end
+
       def default_template(action_name = self.action_name)
         self.view_paths.find_template(default_template_name(action_name), default_template_format)
       end
@@ -1387,7 +909,7 @@ module ActionController #:nodoc:
             action_name = strip_out_controller(action_name)
           end
         end
-        "#{self.controller_path}/#{action_name}"
+        "#{controller_path}/#{action_name}"
       end
 
       def strip_out_controller(path)
@@ -1399,14 +921,15 @@ module ActionController #:nodoc:
       end
 
       def process_cleanup
+        close_session
       end
   end
 
   Base.class_eval do
-    [ Filters, Layout, Benchmarking, Rescue, Flash, MimeResponds, Helpers,
+    [ Filters, Layout, Renderer, Redirector, Responder, Benchmarking, Rescue, Flash, MimeResponds, Helpers,
       Cookies, Caching, Verification, Streaming, SessionManagement,
-      HttpAuthentication::Basic::ControllerMethods, HttpAuthentication::Digest::ControllerMethods,
-      RecordIdentifier, RequestForgeryProtection, Translation
+      HttpAuthentication::Basic::ControllerMethods, HttpAuthentication::Digest::ControllerMethods, RecordIdentifier,
+      RequestForgeryProtection, Translation
     ].each do |mod|
       include mod
     end
diff --git a/actionpack/lib/action_controller/benchmarking.rb b/actionpack/lib/action_controller/base/chained/benchmarking.rb
index 47377e5fa9..066150f58a 100644
--- a/actionpack/lib/action_controller/benchmarking.rb
+++ b/actionpack/lib/action_controller/base/chained/benchmarking.rb
@@ -64,7 +64,7 @@ module ActionController #:nodoc:
 
     private
       def perform_action_with_benchmark
-        if logger
+        if logger && logger.info?
           ms = [Benchmark.ms { perform_action_without_benchmark }, 0.01].max
           logging_view          = defined?(@view_runtime)
           logging_active_record = Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
diff --git a/actionpack/lib/action_controller/filters.rb b/actionpack/lib/action_controller/base/chained/filters.rb
index 9022b8b279..9022b8b279 100644
--- a/actionpack/lib/action_controller/filters.rb
+++ b/actionpack/lib/action_controller/base/chained/filters.rb
diff --git a/actionpack/lib/action_controller/flash.rb b/actionpack/lib/action_controller/base/chained/flash.rb
index 56ee9c67e2..56ee9c67e2 100644
--- a/actionpack/lib/action_controller/flash.rb
+++ b/actionpack/lib/action_controller/base/chained/flash.rb
diff --git a/actionpack/lib/action_controller/cookies.rb b/actionpack/lib/action_controller/base/cookies.rb
index ca380e98d0..ca380e98d0 100644
--- a/actionpack/lib/action_controller/cookies.rb
+++ b/actionpack/lib/action_controller/base/cookies.rb
diff --git a/actionpack/lib/action_controller/helpers.rb b/actionpack/lib/action_controller/base/helpers.rb
index ba65032f6a..ba65032f6a 100644
--- a/actionpack/lib/action_controller/helpers.rb
+++ b/actionpack/lib/action_controller/base/helpers.rb
diff --git a/actionpack/lib/action_controller/http_authentication.rb b/actionpack/lib/action_controller/base/http_authentication.rb
index b6b5267c66..b6b5267c66 100644
--- a/actionpack/lib/action_controller/http_authentication.rb
+++ b/actionpack/lib/action_controller/base/http_authentication.rb
diff --git a/actionpack/lib/action_controller/layout.rb b/actionpack/lib/action_controller/base/layout.rb
index 6ec0c1b304..4fcef6c5d9 100644
--- a/actionpack/lib/action_controller/layout.rb
+++ b/actionpack/lib/action_controller/base/layout.rb
@@ -2,11 +2,7 @@ module ActionController #:nodoc:
   module Layout #:nodoc:
     def self.included(base)
       base.extend(ClassMethods)
-      base.class_eval do
-        class << self
-          alias_method_chain :inherited, :layout
-        end
-      end
+      base.class_inheritable_accessor :layout_name, :layout_conditions
     end
 
     # Layouts reverse the common pattern of including shared headers and footers in many templates to isolate changes in
@@ -159,123 +155,93 @@ module ActionController #:nodoc:
     #
     # This will render the help action with the "help" layout instead of the controller-wide "weblog_standard" layout.
     module ClassMethods
+      extend ActiveSupport::Memoizable
+
       # If a layout is specified, all rendered actions will have their result rendered
       # when the layout <tt>yield</tt>s. This layout can itself depend on instance variables assigned during action
       # performance and have access to them as any normal template would.
       def layout(template_name, conditions = {}, auto = false)
         add_layout_conditions(conditions)
-        write_inheritable_attribute(:layout, template_name)
-        write_inheritable_attribute(:auto_layout, auto)
+        self.layout_name = template_name
+      end
+
+      def memoized_default_layout(formats) #:nodoc:
+        self.layout_name || begin
+          layout = default_layout_name
+          layout.is_a?(String) ? find_layout(layout, formats) : layout
+        rescue ActionView::MissingTemplate
+        end
+      end
+
+      def default_layout(*args)
+        memoized_default_layout(*args)
+        @_memoized_default_layout ||= ::ActiveSupport::ConcurrentHash.new
+        @_memoized_default_layout[args] ||= memoized_default_layout(*args)
+      end
+
+      def memoized_find_layout(layout, formats) #:nodoc:
+        return layout if layout.nil? || layout.respond_to?(:render)
+        prefix = layout.to_s =~ /layouts\// ? nil : "layouts"
+        view_paths.find_by_parts(layout.to_s, formats, prefix)
       end
 
-      def layout_conditions #:nodoc:
-        @layout_conditions ||= read_inheritable_attribute(:layout_conditions)
+      def find_layout(*args)
+        @_memoized_find_layout ||= ::ActiveSupport::ConcurrentHash.new
+        @_memoized_find_layout[args] ||= memoized_find_layout(*args)
       end
 
       def layout_list #:nodoc:
         Array(view_paths).sum([]) { |path| Dir["#{path.to_str}/layouts/**/*"] }
       end
+      memoize :layout_list
 
-      private
-        def inherited_with_layout(child)
-          inherited_without_layout(child)
-          unless child.name.blank?
-            layout_match = child.name.underscore.sub(/_controller$/, '').sub(/^controllers\//, '')
-            child.layout(layout_match, {}, true) unless child.layout_list.grep(%r{layouts/#{layout_match}(\.[a-z][0-9a-z]*)+$}).empty?
-          end
+      def default_layout_name
+        layout_match = name.underscore.sub(/_controller$/, '')
+        if layout_list.grep(%r{layouts/#{layout_match}(\.[a-z][0-9a-z]*)+$}).empty?
+          superclass.default_layout_name if superclass.respond_to?(:default_layout_name)
+        else
+          layout_match
         end
+      end
+      memoize :default_layout_name
 
+      private
         def add_layout_conditions(conditions)
-          write_inheritable_hash(:layout_conditions, normalize_conditions(conditions))
-        end
-
-        def normalize_conditions(conditions)
-          conditions.inject({}) {|hash, (key, value)| hash.merge(key => [value].flatten.map {|action| action.to_s})}
+          # :except => :foo == :except => [:foo] == :except => "foo" == :except => ["foo"]
+          conditions.each {|k, v| conditions[k] = Array(v).map {|a| a.to_s} }
+          write_inheritable_hash(:layout_conditions, conditions)
         end
     end
-
-    # Returns the name of the active layout. If the layout was specified as a method reference (through a symbol), this method
-    # is called and the return value is used. Likewise if the layout was specified as an inline method (through a proc or method
-    # 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, options = {})
-      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
+    
+    def active_layout(name)
+      name = self.class.default_layout(formats) if name == true
+      
+      layout_name = case name
+        when Symbol     then __send__(name)
+        when Proc       then name.call(self)
+        else name
       end
 
-      find_layout(active_layout, default_template_format, options[:html_fallback]) if active_layout
+      self.class.find_layout(layout_name, formats)
     end
 
-    private
-      def default_layout #:nodoc:
-        layout = self.class.read_inheritable_attribute(:layout)
-        return layout unless self.class.read_inheritable_attribute(:auto_layout)
-        find_layout(layout, default_template_format)
-      rescue ActionView::MissingTemplate
-        nil
-      end
-
-      def find_layout(layout, format, html_fallback=false) #:nodoc:
-        view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", format, html_fallback)
-      rescue ActionView::MissingTemplate
-        raise if Mime::Type.lookup_by_extension(format.to_s).html?
-      end
-
-      def pick_layout(options)
-        if options.has_key?(:layout)
-          case layout = options.delete(:layout)
-          when FalseClass
-            nil
-          when NilClass, TrueClass
-            active_layout if action_has_layout? && candidate_for_layout?(:template => default_template_name)
-          else
-            active_layout(layout, :html_fallback => true)
-          end
-        else
-          active_layout if action_has_layout? && candidate_for_layout?(options)
-        end
-      end
+    def _pick_layout(layout_name = nil, implicit = false)
+      return unless layout_name || implicit
+      layout_name = true if layout_name.nil?
+      active_layout(layout_name) if action_has_layout? && layout_name
+    end
 
+    private
       def action_has_layout?
         if conditions = self.class.layout_conditions
-          case
-            when only = conditions[:only]
-              only.include?(action_name)
-            when except = conditions[:except]
-              !except.include?(action_name)
-            else
-              true
+          if only = conditions[:only]
+            return only.include?(action_name)
+          elsif except = conditions[:except]
+            return !except.include?(action_name) 
           end
-        else
-          true
         end
+        true
       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
-            template_object = self.view_paths.find_template(template, default_template_format)
-            # this restores the behavior from 2.2.2, where response.template.template_format was reset
-            # to :html for :js requests with a matching html template.
-            # see v2.2.2, ActionView::Base, lines 328-330
-            @real_format = :html if response.template.template_format == :js && template_object.format == "html"
-            !template_object.exempt_from_layout?
-          rescue ActionView::MissingTemplate
-            true
-          end
-        end
-      rescue ActionView::MissingTemplate
-        false
-      end
-
-      def default_template_format
-        @real_format || response.template.template_format
-      end
   end
 end
diff --git a/actionpack/lib/action_controller/mime_responds.rb b/actionpack/lib/action_controller/base/mime_responds.rb
index b755363873..bac225ab2a 100644
--- a/actionpack/lib/action_controller/mime_responds.rb
+++ b/actionpack/lib/action_controller/base/mime_responds.rb
@@ -109,16 +109,13 @@ module ActionController #:nodoc:
     end
 
     class Responder #:nodoc:
+      
       def initialize(controller)
         @controller = controller
         @request    = controller.request
         @response   = controller.response
 
-        if ActionController::Base.use_accept_header
-          @mime_type_priority = Array(Mime::Type.lookup_by_extension(@request.parameters[:format]) || @request.accepts)
-        else
-          @mime_type_priority = [@request.format]
-        end
+        @mime_type_priority = @request.formats
 
         @order     = []
         @responses = {}
@@ -130,7 +127,7 @@ module ActionController #:nodoc:
         @order << mime_type
 
         @responses[mime_type] ||= Proc.new do
-          @response.template.template_format = mime_type.to_sym
+          @response.template.formats = [mime_type.to_sym]
           @response.content_type = mime_type.to_s
           block_given? ? block.call : @controller.send(:render, :action => @controller.action_name)
         end
diff --git a/actionpack/lib/action_controller/base/redirect.rb b/actionpack/lib/action_controller/base/redirect.rb
new file mode 100644
index 0000000000..2e92117e7c
--- /dev/null
+++ b/actionpack/lib/action_controller/base/redirect.rb
@@ -0,0 +1,91 @@
+module ActionController
+  class RedirectBackError < ActionControllerError #:nodoc:
+    DEFAULT_MESSAGE = 'No HTTP_REFERER was set in the request to this action, so redirect_to :back could not be called successfully. If this is a test, make sure to specify request.env["HTTP_REFERER"].'
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+  
+  module Redirector
+
+    # Redirects the browser to the target specified in +options+. This parameter can take one of three forms:
+    #
+    # * <tt>Hash</tt> - The URL will be generated by calling url_for with the +options+.
+    # * <tt>Record</tt> - The URL will be generated by calling url_for with the +options+, which will reference a named URL for that record.
+    # * <tt>String</tt> starting with <tt>protocol://</tt> (like <tt>http://</tt>) - Is passed straight through as the target for redirection.
+    # * <tt>String</tt> not containing a protocol - The current protocol and host is prepended to the string.
+    # * <tt>:back</tt> - Back to the page that issued the request. Useful for forms that are triggered from multiple places.
+    #   Short-hand for <tt>redirect_to(request.env["HTTP_REFERER"])</tt>
+    #
+    # Examples:
+    #   redirect_to :action => "show", :id => 5
+    #   redirect_to post
+    #   redirect_to "http://www.rubyonrails.org"
+    #   redirect_to "/images/screenshot.jpg"
+    #   redirect_to articles_url
+    #   redirect_to :back
+    #
+    # The redirection happens as a "302 Moved" header unless otherwise specified.
+    #
+    # Examples:
+    #   redirect_to post_url(@post), :status=>:found
+    #   redirect_to :action=>'atom', :status=>:moved_permanently
+    #   redirect_to post_url(@post), :status=>301
+    #   redirect_to :action=>'atom', :status=>302
+    #
+    # When using <tt>redirect_to :back</tt>, if there is no referrer,
+    # RedirectBackError will be raised. You may specify some fallback
+    # behavior for this case by rescuing RedirectBackError.
+    def redirect_to(options = {}, response_status = {}) #:doc:
+      raise ActionControllerError.new("Cannot redirect to nil!") if options.nil?
+
+      if options.is_a?(Hash) && options[:status]
+        status = options.delete(:status)
+      elsif response_status[:status]
+        status = response_status[:status]
+      else
+        status = 302
+      end
+
+      response.redirected_to = options
+
+      case options
+        # The scheme name consist of a letter followed by any combination of
+        # letters, digits, and the plus ("+"), period ("."), or hyphen ("-")
+        # characters; and is terminated by a colon (":").
+        when %r{^\w[\w\d+.-]*:.*}
+          redirect_to_full_url(options, status)
+        when String
+          redirect_to_full_url(request.protocol + request.host_with_port + options, status)
+        when :back
+          if referer = request.headers["Referer"]
+            redirect_to(referer, :status=>status)
+          else
+            raise RedirectBackError
+          end
+        else
+          redirect_to_full_url(url_for(options), status)
+      end
+    end
+
+    def redirect_to_full_url(url, status)
+      raise DoubleRenderError if performed?
+      logger.info("Redirected to #{url}") if logger && logger.info?
+      response.redirect(url, interpret_status(status))
+      @performed_redirect = true
+    end
+    
+    # Clears the redirected results from the headers, resets the status to 200 and returns
+    # the URL that was used to redirect or nil if there was no redirected URL
+    # Note that +redirect_to+ will change the body of the response to indicate a redirection.
+    # The response body is not reset here, see +erase_render_results+
+    def erase_redirect_results #:nodoc:
+      @performed_redirect = false
+      response.redirected_to = nil
+      response.redirected_to_method_params = nil
+      response.status = DEFAULT_RENDER_STATUS_CODE
+      response.headers.delete('Location')
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/base/render.rb b/actionpack/lib/action_controller/base/render.rb
new file mode 100644
index 0000000000..606df58518
--- /dev/null
+++ b/actionpack/lib/action_controller/base/render.rb
@@ -0,0 +1,396 @@
+require 'action_controller/abstract/renderer'
+
+module ActionController
+  DEFAULT_RENDER_STATUS_CODE = "200 OK"
+  
+  class DoubleRenderError < ActionControllerError #:nodoc:
+    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+  
+  module Renderer
+    
+    protected
+    # Renders the content that will be returned to the browser as the response body.
+    #
+    # === Rendering an action
+    #
+    # Action rendering is the most common form and the type used automatically by Action Controller when nothing else is
+    # specified. By default, actions are rendered within the current layout (if one exists).
+    #
+    #   # Renders the template for the action "goal" within the current controller
+    #   render :action => "goal"
+    #
+    #   # Renders the template for the action "short_goal" within the current controller,
+    #   # but without the current active layout
+    #   render :action => "short_goal", :layout => false
+    #
+    #   # Renders the template for the action "long_goal" within the current controller,
+    #   # but with a custom layout
+    #   render :action => "long_goal", :layout => "spectacular"
+    #
+    # === Rendering partials
+    #
+    # Partial rendering in a controller is most commonly used together with Ajax calls that only update one or a few elements on a page
+    # without reloading. Rendering of partials from the controller makes it possible to use the same partial template in
+    # both the full-page rendering (by calling it from within the template) and when sub-page updates happen (from the
+    # controller action responding to Ajax calls). By default, the current layout is not used.
+    #
+    #   # Renders the same partial with a local variable.
+    #   render :partial => "person", :locals => { :name => "david" }
+    #
+    #   # Renders the partial, making @new_person available through
+    #   # the local variable 'person'
+    #   render :partial => "person", :object => @new_person
+    #
+    #   # Renders a collection of the same partial by making each element
+    #   # of @winners available through the local variable "person" as it
+    #   # builds the complete response.
+    #   render :partial => "person", :collection => @winners
+    #
+    #   # Renders a collection of partials but with a custom local variable name
+    #   render :partial => "admin_person", :collection => @winners, :as => :person
+    #
+    #   # Renders the same collection of partials, but also renders the
+    #   # person_divider partial between each person partial.
+    #   render :partial => "person", :collection => @winners, :spacer_template => "person_divider"
+    #
+    #   # Renders a collection of partials located in a view subfolder
+    #   # outside of our current controller.  In this example we will be
+    #   # rendering app/views/shared/_note.r(html|xml)  Inside the partial
+    #   # each element of @new_notes is available as the local var "note".
+    #   render :partial => "shared/note", :collection => @new_notes
+    #
+    #   # Renders the partial with a status code of 500 (internal error).
+    #   render :partial => "broken", :status => 500
+    #
+    # Note that the partial filename must also be a valid Ruby variable name,
+    # so e.g. 2005 and register-user are invalid.
+    #
+    #
+    # == Automatic etagging
+    #
+    # Rendering will automatically insert the etag header on 200 OK responses. The etag is calculated using MD5 of the
+    # response body. If a request comes in that has a matching etag, the response will be changed to a 304 Not Modified
+    # and the response body will be set to an empty string. No etag header will be inserted if it's already set.
+    #
+    # === Rendering a template
+    #
+    # Template rendering works just like action rendering except that it takes a path relative to the template root.
+    # The current layout is automatically applied.
+    #
+    #   # Renders the template located in [TEMPLATE_ROOT]/weblog/show.r(html|xml) (in Rails, app/views/weblog/show.erb)
+    #   render :template => "weblog/show"
+    #
+    #   # Renders the template with a local variable
+    #   render :template => "weblog/show", :locals => {:customer => Customer.new}
+    #
+    # === Rendering a file
+    #
+    # File rendering works just like action rendering except that it takes a filesystem path. By default, the path
+    # is assumed to be absolute, and the current layout is not applied.
+    #
+    #   # Renders the template located at the absolute filesystem path
+    #   render :file => "/path/to/some/template.erb"
+    #   render :file => "c:/path/to/some/template.erb"
+    #
+    #   # Renders a template within the current layout, and with a 404 status code
+    #   render :file => "/path/to/some/template.erb", :layout => true, :status => 404
+    #   render :file => "c:/path/to/some/template.erb", :layout => true, :status => 404
+    #
+    # === Rendering text
+    #
+    # Rendering of text is usually used for tests or for rendering prepared content, such as a cache. By default, text
+    # rendering is not done within the active layout.
+    #
+    #   # Renders the clear text "hello world" with status code 200
+    #   render :text => "hello world!"
+    #
+    #   # Renders the clear text "Explosion!"  with status code 500
+    #   render :text => "Explosion!", :status => 500
+    #
+    #   # Renders the clear text "Hi there!" within the current active layout (if one exists)
+    #   render :text => "Hi there!", :layout => true
+    #
+    #   # Renders the clear text "Hi there!" within the layout
+    #   # placed in "app/views/layouts/special.r(html|xml)"
+    #   render :text => "Hi there!", :layout => "special"
+    #
+    # The <tt>:text</tt> option can also accept a Proc object, which can be used to manually control the page generation. This should
+    # generally be avoided, as it violates the separation between code and content, and because almost everything that can be
+    # done with this method can also be done more cleanly using one of the other rendering methods, most notably templates.
+    #
+    #   # Renders "Hello from code!"
+    #   render :text => proc { |response, output| output.write("Hello from code!") }
+    #
+    # === Rendering XML
+    #
+    # Rendering XML sets the content type to application/xml.
+    #
+    #   # Renders '<name>David</name>'
+    #   render :xml => {:name => "David"}.to_xml
+    #
+    # It's not necessary to call <tt>to_xml</tt> on the object you want to render, since <tt>render</tt> will
+    # automatically do that for you:
+    #
+    #   # Also renders '<name>David</name>'
+    #   render :xml => {:name => "David"}
+    #
+    # === Rendering JSON
+    #
+    # Rendering JSON sets the content type to application/json and optionally wraps the JSON in a callback. It is expected
+    # that the response will be parsed (or eval'd) for use as a data structure.
+    #
+    #   # Renders '{"name": "David"}'
+    #   render :json => {:name => "David"}.to_json
+    #
+    # It's not necessary to call <tt>to_json</tt> on the object you want to render, since <tt>render</tt> will
+    # automatically do that for you:
+    #
+    #   # Also renders '{"name": "David"}'
+    #   render :json => {:name => "David"}
+    #
+    # Sometimes the result isn't handled directly by a script (such as when the request comes from a SCRIPT tag),
+    # so the <tt>:callback</tt> option is provided for these cases.
+    #
+    #   # Renders 'show({"name": "David"})'
+    #   render :json => {:name => "David"}.to_json, :callback => 'show'
+    #
+    # === Rendering an inline template
+    #
+    # Rendering of an inline template works as a cross between text and action rendering where the source for the template
+    # is supplied inline, like text, but its interpreted with ERb or Builder, like action. By default, ERb is used for rendering
+    # and the current layout is not used.
+    #
+    #   # Renders "hello, hello, hello, again"
+    #   render :inline => "<%= 'hello, ' * 3 + 'again' %>"
+    #
+    #   # Renders "<p>Good seeing you!</p>" using Builder
+    #   render :inline => "xml.p { 'Good seeing you!' }", :type => :builder
+    #
+    #   # Renders "hello david"
+    #   render :inline => "<%= 'hello ' + name %>", :locals => { :name => "david" }
+    #
+    # === Rendering inline JavaScriptGenerator page updates
+    #
+    # In addition to rendering JavaScriptGenerator page updates with Ajax in RJS templates (see ActionView::Base for details),
+    # you can also pass the <tt>:update</tt> parameter to +render+, along with a block, to render page updates inline.
+    #
+    #   render :update do |page|
+    #     page.replace_html  'user_list', :partial => 'user', :collection => @users
+    #     page.visual_effect :highlight, 'user_list'
+    #   end
+    #
+    # === Rendering vanilla JavaScript
+    #
+    # In addition to using RJS with render :update, you can also just render vanilla JavaScript with :js.
+    #
+    #   # Renders "alert('hello')" and sets the mime type to text/javascript
+    #   render :js => "alert('hello')"
+    #
+    # === Rendering with status and location headers
+    # All renders take the <tt>:status</tt> and <tt>:location</tt> options and turn them into headers. They can even be used together:
+    #
+    #   render :xml => post.to_xml, :status => :created, :location => post_url(post)
+    def render(options = nil, extra_options = {}, &block) #:doc:
+      raise DoubleRenderError, "Can only render or redirect once per action" if performed?
+
+      options = { :layout => true } if options.nil?
+
+      # This handles render "string", render :symbol, and render object
+      # render string and symbol are handled by render_for_name
+      # render object becomes render :partial => object
+      unless options.is_a?(Hash)
+        if options.is_a?(String) || options.is_a?(Symbol)
+          original, options = options, extra_options
+        else
+          extra_options[:partial], options = options, extra_options
+        end
+      end
+      
+      layout_name = options.delete(:layout)
+
+      _process_options(options)
+      
+      if block_given?
+        @template.send(:_evaluate_assigns_and_ivars)
+
+        generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template, &block)
+        response.content_type = Mime::JS
+        return render_for_text(generator.to_s)
+      end
+      
+      if original
+        return render_for_name(original, layout_name, options) unless block_given?
+      end
+      
+      if options.key?(:text)
+        return render_for_text(@template._render_text(options[:text], 
+          _pick_layout(layout_name), options))
+      end
+
+      file, template = options.values_at(:file, :template)
+      if file || template
+        file = template.sub(/^\//, '') if template
+        return render_for_file(file, [layout_name, !!template], options)
+      end
+      
+      if action_option = options[:action]
+        return render_for_action(action_option, [layout_name, true], options)
+      end
+      
+      if inline = options[:inline]
+        render_for_text(@template._render_inline(inline, _pick_layout(layout_name), options))
+
+      elsif xml = options[:xml]
+        response.content_type ||= Mime::XML
+        render_for_text(xml.respond_to?(:to_xml) ? xml.to_xml : xml)
+
+      elsif js = options[:js]
+        response.content_type ||= Mime::JS
+        render_for_text(js)
+
+      elsif json = options[:json]
+        json = json.to_json unless json.is_a?(String)
+        json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
+        response.content_type ||= Mime::JSON
+        render_for_text(json)
+
+      elsif partial = options[:partial]
+        if partial == true
+          parts = [action_name_base, formats, controller_name, true]
+        elsif partial.is_a?(String)
+          parts = partial_parts(partial, options)
+        else
+          return render_for_text(@template._render_partial(options))
+        end
+        
+        render_for_parts(parts, layout_name, options)
+        
+      elsif options[:nothing]
+        render_for_text(nil)
+
+      else
+        render_for_parts([action_name, formats, controller_path], layout_name, options)
+      end
+    end
+
+    def partial_parts(name, options)
+      segments = name.split("/")
+      parts = segments.pop.split(".")
+
+      case parts.size
+      when 1
+        parts
+      when 2, 3
+        extension = parts.delete_at(1).to_sym
+        if formats.include?(extension)
+          self.formats.replace [extension]
+        end
+        parts.pop if parts.size == 2
+      end
+
+      path = parts.join(".")
+      prefix = segments[0..-1].join("/")
+      prefix = prefix.blank? ? controller_path : prefix
+      parts = [path, formats, prefix]
+      parts.push options[:object] || true
+    end
+
+    def formats
+      @_request.formats.map {|f| f.symbol }.compact
+    end
+
+    def action_name_base(name = action_name)
+      (name.is_a?(String) ? name.sub(/^#{controller_path}\//, '') : name).to_s
+    end
+
+    # Same rules as <tt>render</tt>, but returns a Rack-compatible body
+    # instead of sending the response.
+    def render_to_body(options = nil, &block) #:doc:
+      render(options, &block)
+      response.body
+    ensure
+      response.content_type = nil
+      erase_render_results
+      reset_variables_added_to_assigns
+    end
+
+    def render_to_string(options = {})
+      AbstractController::Renderer.body_to_s(render_to_body(options))
+    end
+
+    # Clears the rendered results, allowing for another render to be performed.
+    def erase_render_results #:nodoc:
+      response.body = []
+      @performed_render = false
+    end
+
+    # Erase both render and redirect results
+    def erase_results #:nodoc:
+      erase_render_results
+      erase_redirect_results
+    end
+    
+    # Return a response that has no content (merely headers). The options
+    # argument is interpreted to be a hash of header names and values.
+    # This allows you to easily return a response that consists only of
+    # significant headers:
+    #
+    #   head :created, :location => person_path(@person)
+    #
+    # It can also be used to return exceptional conditions:
+    #
+    #   return head(:method_not_allowed) unless request.post?
+    #   return head(:bad_request) unless valid_request?
+    #   render
+    def head(*args)
+      if args.length > 2
+        raise ArgumentError, "too many arguments to head"
+      elsif args.empty?
+        raise ArgumentError, "too few arguments to head"
+      end
+      options = args.extract_options!
+      status = interpret_status(args.shift || options.delete(:status) || :ok)
+
+      options.each do |key, value|
+        headers[key.to_s.dasherize.split(/-/).map { |v| v.capitalize }.join("-")] = value.to_s
+      end
+
+      render :nothing => true, :status => status
+    end
+    
+    private
+    def render_for_name(name, layout, options)
+      case name.to_s.index('/')
+      when 0
+        render_for_file(name, layout, options)
+      when nil
+        render_for_action(name, layout, options)
+      else
+        render_for_file(name.sub(/^\//, ''), [layout, true], options)
+      end
+    end
+  
+    def render_for_parts(parts, layout, options = {})
+      tmp = view_paths.find_by_parts(*parts)
+      
+      layout = _pick_layout(*layout) unless tmp.exempt_from_layout?
+            
+      render_for_text(
+        @template._render_template_with_layout(tmp, layout, options, parts[3]))
+    end
+
+    def render_for_file(file, layout, options)
+      render_for_parts([file, [request.format.to_sym]], layout, options)
+    end
+    
+    def render_for_action(name, layout, options)
+      parts = [action_name_base(name), formats, controller_name]
+      render_for_parts(parts, layout, options)
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/request_forgery_protection.rb b/actionpack/lib/action_controller/base/request_forgery_protection.rb
index f3e6288c26..3067122ceb 100644
--- a/actionpack/lib/action_controller/request_forgery_protection.rb
+++ b/actionpack/lib/action_controller/base/request_forgery_protection.rb
@@ -81,12 +81,13 @@ module ActionController #:nodoc:
       
       # Returns true or false if a request is verified.  Checks:
       #
-      # * is the format restricted?  By default, only HTML and AJAX requests are checked.
+      # * is the format restricted?  By default, only HTML requests are checked.
       # * is it a GET request?  Gets should be safe and idempotent
       # * Does the form_authenticity_token match the given token value from the params?
       def verified_request?
         !protect_against_forgery?     ||
           request.method == :get      ||
+          request.xhr?                ||
           !verifiable_request_format? ||
           form_authenticity_token == params[request_forgery_protection_token]
       end
diff --git a/actionpack/lib/action_controller/base/responder.rb b/actionpack/lib/action_controller/base/responder.rb
new file mode 100644
index 0000000000..1aee980da6
--- /dev/null
+++ b/actionpack/lib/action_controller/base/responder.rb
@@ -0,0 +1,43 @@
+module ActionController
+  module Responder
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+    
+    private
+    def render_for_text(text) #:nodoc:
+      @performed_render = true
+
+      case text
+      when Proc
+        response.body = text
+      when nil
+        # Safari 2 doesn't pass response headers if the response is zero-length
+        if response.body_parts.empty?
+          response.body_parts << ' '
+        end
+      else
+        response.body_parts << text
+      end
+    end
+    
+    # Returns a set of the methods defined as actions in your controller
+    def action_methods
+      self.class.action_methods
+    end
+    
+    module ClassMethods
+      def action_methods
+        @action_methods ||=
+          # All public instance methods of this class, including ancestors
+          public_instance_methods(true).map { |m| m.to_s }.to_set -
+          # Except for public instance methods of Base and its ancestors
+          Base.public_instance_methods(true).map { |m| m.to_s } +
+          # Be sure to include shadowed public instance methods of this class
+          public_instance_methods(false).map { |m| m.to_s } -
+          # And always exclude explicitly hidden actions
+          hidden_actions
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/session_management.rb b/actionpack/lib/action_controller/base/session_management.rb
index b556f04649..ffce8e1bd1 100644
--- a/actionpack/lib/action_controller/session_management.rb
+++ b/actionpack/lib/action_controller/base/session_management.rb
@@ -26,7 +26,7 @@ module ActionController #:nodoc:
         if defined? @@session_store
           @@session_store
         else
-          Session::CookieStore
+          ActionDispatch::Session::CookieStore
         end
       end
 
diff --git a/actionpack/lib/action_controller/streaming.rb b/actionpack/lib/action_controller/base/streaming.rb
index 9f80f48c3d..9f80f48c3d 100644
--- a/actionpack/lib/action_controller/streaming.rb
+++ b/actionpack/lib/action_controller/base/streaming.rb
diff --git a/actionpack/lib/action_controller/verification.rb b/actionpack/lib/action_controller/base/verification.rb
index c62b81b666..c62b81b666 100644
--- a/actionpack/lib/action_controller/verification.rb
+++ b/actionpack/lib/action_controller/base/verification.rb
diff --git a/actionpack/lib/action_controller/caching.rb b/actionpack/lib/action_controller/caching.rb
index 80d13e25f1..ffd8081edc 100644
--- a/actionpack/lib/action_controller/caching.rb
+++ b/actionpack/lib/action_controller/caching.rb
@@ -13,7 +13,7 @@ module ActionController #:nodoc:
   #
   # == Caching stores
   #
-  # All the caching stores from ActiveSupport::Cache is available to be used as backends for Action Controller caching. This setting only
+  # All the caching stores from ActiveSupport::Cache are available to be used as backends for Action Controller caching. This setting only
   # affects action and fragment caching as page caching is always written to disk.
   #
   # Configuration examples (MemoryStore is the default):
diff --git a/actionpack/lib/action_controller/caching/actions.rb b/actionpack/lib/action_controller/caching/actions.rb
index 87b5029e57..b99feddf77 100644
--- a/actionpack/lib/action_controller/caching/actions.rb
+++ b/actionpack/lib/action_controller/caching/actions.rb
@@ -134,7 +134,7 @@ module ActionController #:nodoc:
           end
         end
         
-        # When true, infer_extension will look up the cache path extension from the request's path & format.
+        # If +infer_extension+ is true, the cache path extension is looked up from the request's path & format.
         # This is desirable when reading and writing the cache, but not when expiring the cache -
         # expire_action should expire the same files regardless of the request format.
         def initialize(controller, options = {}, infer_extension = true)
diff --git a/actionpack/lib/action_controller/cgi_ext.rb b/actionpack/lib/action_controller/cgi_ext.rb
deleted file mode 100644
index 406b6f06d6..0000000000
--- a/actionpack/lib/action_controller/cgi_ext.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-require 'action_controller/cgi_ext/stdinput'
-require 'action_controller/cgi_ext/query_extension'
-require 'action_controller/cgi_ext/cookie'
-
-class CGI #:nodoc:
-  include ActionController::CgiExt::Stdinput
-
-  class << self
-    alias :escapeHTML_fail_on_nil :escapeHTML
-
-    def escapeHTML(string)
-      escapeHTML_fail_on_nil(string) unless string.nil?
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/cgi_ext/cookie.rb b/actionpack/lib/action_controller/cgi_ext/cookie.rb
deleted file mode 100644
index 9cd19bb12d..0000000000
--- a/actionpack/lib/action_controller/cgi_ext/cookie.rb
+++ /dev/null
@@ -1,112 +0,0 @@
-require 'delegate'
-
-CGI.module_eval { remove_const "Cookie" }
-
-# TODO: document how this differs from stdlib CGI::Cookie
-class CGI #:nodoc:
-  class Cookie < DelegateClass(Array)
-    attr_accessor :name, :value, :path, :domain, :expires
-    attr_reader :secure, :http_only
-
-    # Creates a new CGI::Cookie object.
-    #
-    # The contents of the cookie can be specified as a +name+ and one
-    # or more +value+ arguments.  Alternatively, the contents can
-    # be specified as a single hash argument.  The possible keywords of
-    # this hash are as follows:
-    #
-    # * <tt>:name</tt> - The name of the cookie.  Required.
-    # * <tt>:value</tt> - The cookie's value or list of values.
-    # * <tt>:path</tt> - The path for which this cookie applies.  Defaults to the
-    #   base directory of the CGI script.
-    # * <tt>:domain</tt> - The domain for which this cookie applies.
-    # * <tt>:expires</tt> - The time at which this cookie expires, as a Time object.
-    # * <tt>:secure</tt> - Whether this cookie is a secure cookie or not (defaults to
-    #   +false+). Secure cookies are only transmitted to HTTPS servers.
-    # * <tt>:http_only</tt> - Whether this cookie can be accessed by client side scripts (e.g. document.cookie) or only over HTTP.
-    #   More details in http://msdn2.microsoft.com/en-us/library/system.web.httpcookie.httponly.aspx. Defaults to +false+. 
-    #
-    # These keywords correspond to attributes of the cookie object.
-    def initialize(name = '', *value)
-      if name.kind_of?(String)
-        @name = name
-        @value = Array(value)
-        @domain = nil
-        @expires = nil
-        @secure = false
-        @http_only = false
-        @path = nil
-      else
-        @name = name['name']
-        @value = (name['value'].kind_of?(String) ? [name['value']] : Array(name['value'])).delete_if(&:blank?)
-        @domain = name['domain']
-        @expires = name['expires']
-        @secure = name['secure'] || false
-        @http_only = name['http_only'] || false
-        @path = name['path']
-      end
-
-      raise ArgumentError, "`name' required" unless @name
-
-      # simple support for IE
-      unless @path
-        %r|^(.*/)|.match(ENV['SCRIPT_NAME'])
-        @path = ($1 or '')
-      end
-
-      super(@value)
-    end
-
-    # Sets whether the Cookie is a secure cookie or not.
-    def secure=(val)
-      @secure = val == true
-    end
-
-    # Sets whether the Cookie is an HTTP only cookie or not.
-    def http_only=(val)
-      @http_only = val == true
-    end
-
-    # Converts the Cookie to its string representation.
-    def to_s
-      buf = ''
-      buf << @name << '='
-      buf << (@value.kind_of?(String) ? CGI::escape(@value) : @value.collect{|v| CGI::escape(v) }.join("&"))
-      buf << '; domain=' << @domain if @domain
-      buf << '; path=' << @path if @path
-      buf << '; expires=' << CGI::rfc1123_date(@expires) if @expires
-      buf << '; secure' if @secure
-      buf << '; HttpOnly' if @http_only
-      buf
-    end
-
-    # FIXME: work around broken 1.8.7 DelegateClass#respond_to?
-    def respond_to?(method, include_private = false)
-      return true if super(method)
-      return __getobj__.respond_to?(method, include_private)
-    end
-
-    # Parses a raw cookie string into a hash of <tt>cookie-name => cookie-object</tt>
-    # pairs.
-    #
-    #   cookies = CGI::Cookie::parse("raw_cookie_string")
-    #     # => { "name1" => cookie1, "name2" => cookie2, ... }
-    #
-    def self.parse(raw_cookie)
-      cookies = Hash.new([])
-
-      if raw_cookie
-        raw_cookie.split(/;\s?/).each do |pairs|
-          name, value = pairs.split('=',2)
-          next unless name and value
-          name = CGI::unescape(name)
-          unless cookies.has_key?(name)
-            cookies[name] = new(name, CGI::unescape(value))
-          end
-        end
-      end
-
-      cookies
-    end
-  end # class Cookie
-end
diff --git a/actionpack/lib/action_controller/cgi_ext/query_extension.rb b/actionpack/lib/action_controller/cgi_ext/query_extension.rb
deleted file mode 100644
index 9620fd2873..0000000000
--- a/actionpack/lib/action_controller/cgi_ext/query_extension.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-require 'cgi'
-
-class CGI #:nodoc:
-  module QueryExtension
-    # Remove the old initialize_query method before redefining it.
-    remove_method :initialize_query
-
-    # Neuter CGI parameter parsing.
-    def initialize_query
-      # Fix some strange request environments.
-      env_table['REQUEST_METHOD'] ||= 'GET'
-
-      # POST assumes missing Content-Type is application/x-www-form-urlencoded.
-      if env_table['CONTENT_TYPE'].blank? && env_table['REQUEST_METHOD'] == 'POST'
-        env_table['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
-      end
-
-      @cookies = CGI::Cookie::parse(env_table['HTTP_COOKIE'] || env_table['COOKIE'])
-      @params = {}
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/cgi_ext/stdinput.rb b/actionpack/lib/action_controller/cgi_ext/stdinput.rb
deleted file mode 100644
index 5e9b6784af..0000000000
--- a/actionpack/lib/action_controller/cgi_ext/stdinput.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-require 'cgi'
-
-module ActionController
-  module CgiExt
-    # Publicize the CGI's internal input stream so we can lazy-read
-    # request.body. Make it writable so we don't have to play $stdin games.
-    module Stdinput
-      def self.included(base)
-        base.class_eval do
-          remove_method :stdinput
-          attr_accessor :stdinput
-        end
-
-        base.alias_method_chain :initialize, :stdinput
-      end
-
-      def initialize_with_stdinput(type = nil, stdinput = $stdin)
-        @stdinput = stdinput
-        @stdinput.set_encoding(Encoding::BINARY) if @stdinput.respond_to?(:set_encoding)
-        initialize_without_stdinput(type || 'query')
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/cgi_process.rb b/actionpack/lib/action_controller/cgi_process.rb
deleted file mode 100644
index 54ff04cfd2..0000000000
--- a/actionpack/lib/action_controller/cgi_process.rb
+++ /dev/null
@@ -1,77 +0,0 @@
-require 'action_controller/cgi_ext'
-
-module ActionController #:nodoc:
-  class CGIHandler
-    module ProperStream
-      def each
-        while line = gets
-          yield line
-        end
-      end
-
-      def read(*args)
-        if args.empty?
-          super || ""
-        else
-          super
-        end
-      end
-    end
-
-    def self.dispatch_cgi(app, cgi, out = $stdout)
-      env = cgi.__send__(:env_table)
-      env.delete "HTTP_CONTENT_LENGTH"
-
-      cgi.stdinput.extend ProperStream
-
-      env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
-
-      env.update({
-        "rack.version" => [0,1],
-        "rack.input" => cgi.stdinput,
-        "rack.errors" => $stderr,
-        "rack.multithread" => false,
-        "rack.multiprocess" => true,
-        "rack.run_once" => false,
-        "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-      })
-
-      env["QUERY_STRING"] ||= ""
-      env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-      env["REQUEST_PATH"] ||= "/"
-      env.delete "PATH_INFO" if env["PATH_INFO"] == ""
-
-      status, headers, body = app.call(env)
-      begin
-        out.binmode if out.respond_to?(:binmode)
-        out.sync = false if out.respond_to?(:sync=)
-
-        headers['Status'] = status.to_s
-
-        if headers.include?('Set-Cookie')
-          headers['cookie'] = headers.delete('Set-Cookie').split("\n")
-        end
-
-        out.write(cgi.header(headers))
-
-        body.each { |part|
-          out.write part
-          out.flush if out.respond_to?(:flush)
-        }
-      ensure
-        body.close if body.respond_to?(:close)
-      end
-    end
-  end
-
-  class CgiRequest #:nodoc:
-    DEFAULT_SESSION_OPTIONS = {
-      :database_manager  => nil,
-      :prefix            => "ruby_sess.",
-      :session_path      => "/",
-      :session_key       => "_session_id",
-      :cookie_only       => true,
-      :session_http_only => true
-    }
-  end
-end
diff --git a/actionpack/lib/action_controller/deprecated.rb b/actionpack/lib/action_controller/deprecated.rb
new file mode 100644
index 0000000000..d98e9ac7bd
--- /dev/null
+++ b/actionpack/lib/action_controller/deprecated.rb
@@ -0,0 +1,2 @@
+ActionController::AbstractRequest = ActionController::Request = ActionDispatch::Request
+ActionController::AbstractResponse = ActionController::Response = ActionDispatch::Response
diff --git a/actionpack/lib/action_controller/dispatcher.rb b/actionpack/lib/action_controller/dispatch/dispatcher.rb
index 07931e4a4a..bb9d8bd063 100644
--- a/actionpack/lib/action_controller/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatch/dispatcher.rb
@@ -5,8 +5,8 @@ module ActionController
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
-          unless self.middleware.include?(Reloader)
-            self.middleware.insert_after(Failsafe, Reloader)
+          unless self.middleware.include?(ActionDispatch::Reloader)
+            self.middleware.insert_after(ActionDispatch::Failsafe, ActionDispatch::Reloader)
           end
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
@@ -23,11 +23,6 @@ module ActionController
         end
       end
 
-      # DEPRECATE: Remove CGI support
-      def dispatch(cgi = nil, session_options = CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
-        new(output).dispatch_cgi(cgi, session_options)
-      end
-
       # Add a preparation callback. Preparation callbacks are run before every
       # request in development mode, and before the first request in production
       # mode.
@@ -43,13 +38,7 @@ module ActionController
       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
+        new.send :run_callbacks, :prepare_dispatch
       end
 
       def reload_application
@@ -68,7 +57,7 @@ module ActionController
     end
 
     cattr_accessor :middleware
-    self.middleware = MiddlewareStack.new do |middleware|
+    self.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
       middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
       middleware.instance_eval(File.read(middlewares))
     end
@@ -76,19 +65,22 @@ module ActionController
     include ActiveSupport::Callbacks
     define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
 
-    # DEPRECATE: Remove arguments, since they are only used by CGI
-    def initialize(output = $stdout, request = nil, response = nil)
-      @output = output
-      @app = @@middleware.build(lambda { |env| self.dup._call(env) })
+    def initialize
+      @app = @@middleware.build(lambda { |env| self._call(env) })
+      freeze
     end
 
-    def dispatch
+    def call(env)
+      @app.call(env)
+    end
+
+    def _call(env)
       begin
         run_callbacks :before_dispatch
-        Routing::Routes.call(@env)
+        Routing::Routes.call(env)
       rescue Exception => exception
         if controller ||= (::ApplicationController rescue Base)
-          controller.call_with_exception(@env, exception).to_a
+          controller.call_with_exception(env, exception).to_a
         else
           raise exception
         end
@@ -97,20 +89,6 @@ module ActionController
       end
     end
 
-    # DEPRECATE: Remove CGI support
-    def dispatch_cgi(cgi, session_options)
-      CGIHandler.dispatch_cgi(self, cgi, @output)
-    end
-
-    def call(env)
-      @app.call(env)
-    end
-
-    def _call(env)
-      @env = env
-      dispatch
-    end
-
     def flush_logger
       Base.logger.flush
     end
diff --git a/actionpack/lib/action_controller/middlewares.rb b/actionpack/lib/action_controller/dispatch/middlewares.rb
index 371cf6d8f7..b62b4f84a1 100644
--- a/actionpack/lib/action_controller/middlewares.rb
+++ b/actionpack/lib/action_controller/dispatch/middlewares.rb
@@ -2,12 +2,12 @@ use "Rack::Lock", :if => lambda {
   !ActionController::Base.allow_concurrency
 }
 
-use "ActionController::Failsafe"
+use "ActionDispatch::Failsafe"
 
 use lambda { ActionController::Base.session_store },
     lambda { ActionController::Base.session_options }
 
-use "ActionController::RewindableInput"
-use "ActionController::ParamsParser"
+use "ActionDispatch::RewindableInput"
+use "ActionDispatch::ParamsParser"
 use "Rack::MethodOverride"
 use "Rack::Head"
diff --git a/actionpack/lib/action_controller/rescue.rb b/actionpack/lib/action_controller/dispatch/rescue.rb
index 242c8da920..df80ac0909 100644
--- a/actionpack/lib/action_controller/rescue.rb
+++ b/actionpack/lib/action_controller/dispatch/rescue.rb
@@ -38,7 +38,7 @@ module ActionController #:nodoc:
       'ActionView::TemplateError'         => 'template_error'
     }
 
-    RESCUES_TEMPLATE_PATH = ActionView::Template::EagerPath.new_and_loaded(
+    RESCUES_TEMPLATE_PATH = ActionView::Template::FileSystemPath.new(
       File.join(File.dirname(__FILE__), "templates"))
 
     def self.included(base) #:nodoc:
@@ -60,8 +60,8 @@ module ActionController #:nodoc:
 
     module ClassMethods
       def call_with_exception(env, exception) #:nodoc:
-        request = env["action_controller.rescue.request"] ||= Request.new(env)
-        response = env["action_controller.rescue.response"] ||= Response.new
+        request = env["action_controller.rescue.request"] ||= ActionDispatch::Request.new(env)
+        response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
         new.process(request, response, :rescue_action, exception)
       end
     end
@@ -131,11 +131,13 @@ module ActionController #:nodoc:
         @template.instance_variable_set("@exception", exception)
         @template.instance_variable_set("@rescues_path", RESCUES_TEMPLATE_PATH)
         @template.instance_variable_set("@contents",
-          @template.render(:file => template_path_for_local_rescue(exception)))
+          @template._render_template(template_path_for_local_rescue(exception)))
 
         response.content_type = Mime::HTML
-        render_for_file(rescues_path("layout"),
-          response_code_for_rescue(exception))
+        response.status = interpret_status(response_code_for_rescue(exception))
+        
+        content = @template._render_template(rescues_path("layout"))
+        render_for_text(content)
       end
 
       def rescue_action_without_handler(exception)
@@ -163,7 +165,7 @@ module ActionController #:nodoc:
       end
 
       def rescues_path(template_name)
-        RESCUES_TEMPLATE_PATH["rescues/#{template_name}.erb"]
+        RESCUES_TEMPLATE_PATH.find_by_parts("rescues/#{template_name}.erb")
       end
 
       def template_path_for_local_rescue(exception)
diff --git a/actionpack/lib/action_controller/templates/rescues/_request_and_response.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/_request_and_response.erb
index 64b34650b1..64b34650b1 100644
--- a/actionpack/lib/action_controller/templates/rescues/_request_and_response.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/_request_and_response.erb
diff --git a/actionpack/lib/action_controller/templates/rescues/_trace.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/_trace.erb
index bb2d8375bd..bb2d8375bd 100644
--- a/actionpack/lib/action_controller/templates/rescues/_trace.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/_trace.erb
diff --git a/actionpack/lib/action_controller/templates/rescues/diagnostics.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb
index 669da1b26e..e5c647c826 100644
--- a/actionpack/lib/action_controller/templates/rescues/diagnostics.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb
@@ -6,6 +6,5 @@
 </h1>
 <pre><%=h @exception.clean_message %></pre>
 
-<%= render :file => @rescues_path["rescues/_trace.erb"] %>
-
-<%= render :file => @rescues_path["rescues/_request_and_response.erb"] %>
+<%= @template._render_template(@rescues_path.find_by_parts("rescues/_trace.erb")) %>
+<%= @template._render_template(@rescues_path.find_by_parts("rescues/_request_and_response.erb")) %>
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/templates/rescues/layout.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/layout.erb
index 4a04742e40..4a04742e40 100644
--- a/actionpack/lib/action_controller/templates/rescues/layout.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/layout.erb
diff --git a/actionpack/lib/action_controller/templates/rescues/missing_template.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/missing_template.erb
index dbfdf76947..dbfdf76947 100644
--- a/actionpack/lib/action_controller/templates/rescues/missing_template.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/missing_template.erb
diff --git a/actionpack/lib/action_controller/templates/rescues/routing_error.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/routing_error.erb
index ccfa858cce..ccfa858cce 100644
--- a/actionpack/lib/action_controller/templates/rescues/routing_error.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/routing_error.erb
diff --git a/actionpack/lib/action_controller/templates/rescues/template_error.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/template_error.erb
index 2e34e03bd5..2e34e03bd5 100644
--- a/actionpack/lib/action_controller/templates/rescues/template_error.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/template_error.erb
diff --git a/actionpack/lib/action_controller/templates/rescues/unknown_action.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/unknown_action.erb
index 683379da10..683379da10 100644
--- a/actionpack/lib/action_controller/templates/rescues/unknown_action.erb
+++ b/actionpack/lib/action_controller/dispatch/templates/rescues/unknown_action.erb
diff --git a/actionpack/lib/action_controller/new_base.rb b/actionpack/lib/action_controller/new_base.rb
new file mode 100644
index 0000000000..7c65f1cdc1
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base.rb
@@ -0,0 +1,7 @@
+module ActionController
+  autoload :AbstractBase, "action_controller/new_base/base"
+  autoload :HideActions,  "action_controller/new_base/hide_actions"
+  autoload :Layouts,      "action_controller/new_base/layouts"
+  autoload :Renderer,     "action_controller/new_base/renderer"
+  autoload :UrlFor,       "action_controller/new_base/url_for"
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/base.rb b/actionpack/lib/action_controller/new_base/base.rb
new file mode 100644
index 0000000000..08e7a1a0e7
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/base.rb
@@ -0,0 +1,60 @@
+module ActionController
+  class AbstractBase < AbstractController::Base
+    
+    # :api: public
+    attr_internal :request, :response, :params
+
+    # :api: public
+    def self.controller_name
+      @controller_name ||= controller_path.split("/").last
+    end
+
+    # :api: public
+    def controller_name() self.class.controller_name end
+
+    # :api: public    
+    def self.controller_path
+      @controller_path ||= self.name.sub(/Controller$/, '').underscore
+    end
+    
+    # :api: public    
+    def controller_path() self.class.controller_path end
+      
+    # :api: private      
+    def self.action_methods
+      @action_names ||= Set.new(self.public_instance_methods - self::CORE_METHODS)
+    end
+    
+    # :api: private    
+    def self.action_names() action_methods end
+    
+    # :api: private        
+    def action_methods() self.class.action_names end
+
+    # :api: private
+    def action_names() action_methods end
+    
+    # :api: plugin
+    def self.call(env)
+      controller = new
+      controller.call(env).to_rack
+    end
+    
+    # :api: plugin
+    def response_body=(body)
+      @_response.body = body
+    end
+    
+    # :api: private
+    def call(env)
+      @_request = ActionDispatch::Request.new(env)
+      @_response = ActionDispatch::Response.new
+      process(@_request.parameters[:action])
+    end
+    
+    # :api: private
+    def to_rack
+      response.to_a
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/hide_actions.rb b/actionpack/lib/action_controller/new_base/hide_actions.rb
new file mode 100644
index 0000000000..473a8ea72b
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/hide_actions.rb
@@ -0,0 +1,31 @@
+module ActionController
+  module HideActions
+    setup do
+      extlib_inheritable_accessor :hidden_actions
+      self.hidden_actions ||= Set.new      
+    end
+    
+    def action_methods() self.class.action_names end
+    def action_names() action_methods end    
+      
+  private
+  
+    def respond_to_action?(action_name)
+      !hidden_actions.include?(action_name) && (super || respond_to?(:method_missing))
+    end
+    
+    module ClassMethods
+      def hide_action(*args)
+        args.each do |arg|
+          self.hidden_actions << arg.to_s
+        end
+      end
+      
+      def action_methods
+        @action_names ||= Set.new(super.reject {|name| self.hidden_actions.include?(name.to_s)})
+      end
+
+      def self.action_names() action_methods end
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/layouts.rb b/actionpack/lib/action_controller/new_base/layouts.rb
new file mode 100644
index 0000000000..a8e0809ac6
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/layouts.rb
@@ -0,0 +1,37 @@
+module ActionController
+  module Layouts
+    depends_on ActionController::Renderer
+    depends_on AbstractController::Layouts
+    
+    module ClassMethods
+      def _implied_layout_name
+        controller_path
+      end
+    end
+    
+    def render_to_body(options)
+      # render :text => ..., :layout => ...
+      # or
+      # render :anything_else
+      if !options.key?(:text) || options.key?(:layout)
+        options[:_layout] = options.key?(:layout) ? _layout_for_option(options[:layout]) : _default_layout
+      end
+      
+      super
+    end
+    
+  private
+  
+    def _layout_for_option(name)
+      case name
+      when String     then _layout_for_name(name)
+      when true       then _default_layout(true)
+      when false, nil then nil
+      else
+        raise ArgumentError, 
+          "String, true, or false, expected for `layout'; you passed #{name.inspect}"        
+      end
+    end
+    
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/renderer.rb b/actionpack/lib/action_controller/new_base/renderer.rb
new file mode 100644
index 0000000000..ed34c46aed
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/renderer.rb
@@ -0,0 +1,62 @@
+module ActionController
+  module Renderer
+    depends_on AbstractController::Renderer
+    
+    def initialize(*)
+      self.formats = [:html]
+      super
+    end
+    
+    def render(action, options = {})
+      # TODO: Move this into #render_to_body
+      if action.is_a?(Hash)
+        options, action = action, nil 
+      else
+        options.merge! :action => action
+      end
+      
+      _process_options(options)
+      
+      self.response_body = render_to_body(options)
+    end
+
+    def render_to_body(options)
+      unless options.is_a?(Hash)
+        options = {:action => options}
+      end
+
+      if options.key?(:text)
+        options[:_template] = ActionView::TextTemplate.new(_text(options))
+        template = nil
+      elsif options.key?(:template)
+        options[:_template_name] = options[:template]
+      elsif options.key?(:action)
+        options[:_template_name] = options[:action].to_s
+        options[:_prefix] = _prefix 
+      end
+      
+      super(options)
+    end
+    
+  private
+  
+    def _prefix
+      controller_path
+    end  
+  
+    def _text(options)
+      text = options[:text]
+
+      case text
+      when nil then " "
+      else text.to_s
+      end
+    end
+  
+    def _process_options(options)
+      if status = options[:status]
+        response.status = status.to_i
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/url_for.rb b/actionpack/lib/action_controller/new_base/url_for.rb
new file mode 100644
index 0000000000..af5b21012b
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/url_for.rb
@@ -0,0 +1,40 @@
+module ActionController
+  module UrlFor
+    def initialize_current_url
+      @url = UrlRewriter.new(request, params.clone)
+    end
+
+    # Overwrite to implement a number of default options that all url_for-based methods will use. The default options should come in
+    # the form of a hash, just like the one you would use for url_for directly. Example:
+    #
+    #   def default_url_options(options)
+    #     { :project => @project.active? ? @project.url_name : "unknown" }
+    #   end
+    #
+    # As you can infer from the example, this is mostly useful for situations where you want to centralize dynamic decisions about the
+    # urls as they stem from the business domain. Please note that any individual url_for call can always override the defaults set
+    # by this method.
+    def default_url_options(options = nil)
+    end
+    
+    def rewrite_options(options) #:nodoc:
+      if defaults = default_url_options(options)
+        defaults.merge(options)
+      else
+        options
+      end
+    end
+    
+    def url_for(options = {})
+      options ||= {}
+      case options
+        when String
+          options
+        when Hash
+          @url.rewrite(rewrite_options(options))
+        else
+          polymorphic_url(options)
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/record_identifier.rb b/actionpack/lib/action_controller/record_identifier.rb
index 742d290ad6..6bda27e23a 100644
--- a/actionpack/lib/action_controller/record_identifier.rb
+++ b/actionpack/lib/action_controller/record_identifier.rb
@@ -1,4 +1,4 @@
-module ActionController  
+module ActionController
   # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records or 
   # Active Resources or pretty much any other model type that has an id. These patterns are then used to try elevate
   # the view actions to a higher logical level. Example:
diff --git a/actionpack/lib/action_controller/rewindable_input.rb b/actionpack/lib/action_controller/rewindable_input.rb
deleted file mode 100644
index cedfb7fd75..0000000000
--- a/actionpack/lib/action_controller/rewindable_input.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-module ActionController
-  class RewindableInput
-    class RewindableIO < ActiveSupport::BasicObject
-      def initialize(io)
-        @io = io
-        @rewindable = io.is_a?(::StringIO)
-      end
-
-      def method_missing(method, *args, &block)
-        unless @rewindable
-          @io = ::StringIO.new(@io.read)
-          @rewindable = true
-        end
-
-        @io.__send__(method, *args, &block)
-      end
-    end
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      env['rack.input'] = RewindableIO.new(env['rack.input'])
-      @app.call(env)
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/polymorphic_routes.rb b/actionpack/lib/action_controller/routing/generation/polymorphic_routes.rb
index d9b614c237..d9b614c237 100644
--- a/actionpack/lib/action_controller/polymorphic_routes.rb
+++ b/actionpack/lib/action_controller/routing/generation/polymorphic_routes.rb
diff --git a/actionpack/lib/action_controller/url_rewriter.rb b/actionpack/lib/action_controller/routing/generation/url_rewriter.rb
index bb6cb437b7..16720b915b 100644
--- a/actionpack/lib/action_controller/url_rewriter.rb
+++ b/actionpack/lib/action_controller/routing/generation/url_rewriter.rb
@@ -68,29 +68,17 @@ module ActionController
   # This generates, among other things, the method <tt>users_path</tt>. By default,
   # this method is accessible from your controllers, views and mailers. If you need
   # to access this auto-generated method from other places (such as a model), then
-  # you can do that in two ways.
-  #
-  # The first way is to include ActionController::UrlWriter in your class:
+  # you can do that by including ActionController::UrlWriter in your class:
   #
   #   class User < ActiveRecord::Base
-  #     include ActionController::UrlWriter         # !!!
+  #     include ActionController::UrlWriter
   #
-  #     def name=(value)
-  #       write_attribute('name', value)
-  #       write_attribute('base_uri', users_path)   # !!!
+  #     def base_uri
+  #       user_path(self)
   #     end
   #   end
   #
-  # The second way is to access them through ActionController::UrlWriter.
-  # The autogenerated named routes methods are available as class methods:
-  #
-  #   class User < ActiveRecord::Base
-  #     def name=(value)
-  #       write_attribute('name', value)
-  #       path = ActionController::UrlWriter.users_path   # !!!
-  #       write_attribute('base_uri', path)               # !!!
-  #     end
-  #   end
+  #   User.find(1).base_uri # => "/users/1"
   module UrlWriter
     def self.included(base) #:nodoc:
       ActionController::Routing::Routes.install_helpers(base)
diff --git a/actionpack/lib/action_controller/resources.rb b/actionpack/lib/action_controller/routing/resources.rb
index 86abb7b2f4..86abb7b2f4 100644
--- a/actionpack/lib/action_controller/resources.rb
+++ b/actionpack/lib/action_controller/routing/resources.rb
diff --git a/actionpack/lib/action_controller/routing/route_set.rb b/actionpack/lib/action_controller/routing/route_set.rb
index 044ace7de1..70cd1f642d 100644
--- a/actionpack/lib/action_controller/routing/route_set.rb
+++ b/actionpack/lib/action_controller/routing/route_set.rb
@@ -428,7 +428,7 @@ module ActionController
       end
 
       def call(env)
-        request = Request.new(env)
+        request = ActionDispatch::Request.new(env)
         app = Routing::Routes.recognize(request)
         app.call(env).to_a
       end
diff --git a/actionpack/lib/action_controller/status_codes.rb b/actionpack/lib/action_controller/status_codes.rb
deleted file mode 100644
index 4977c79491..0000000000
--- a/actionpack/lib/action_controller/status_codes.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-module ActionController
-  module StatusCodes #:nodoc:
-    # Defines the standard HTTP status codes, by integer, with their
-    # corresponding default message texts.
-    # Source: http://www.iana.org/assignments/http-status-codes
-    STATUS_CODES = {
-      100 => "Continue",
-      101 => "Switching Protocols",
-      102 => "Processing",
-
-      200 => "OK",
-      201 => "Created",
-      202 => "Accepted",
-      203 => "Non-Authoritative Information",
-      204 => "No Content",
-      205 => "Reset Content",
-      206 => "Partial Content",
-      207 => "Multi-Status",
-      226 => "IM Used",
-
-      300 => "Multiple Choices",
-      301 => "Moved Permanently",
-      302 => "Found",
-      303 => "See Other",
-      304 => "Not Modified",
-      305 => "Use Proxy",
-      307 => "Temporary Redirect",
-
-      400 => "Bad Request",
-      401 => "Unauthorized",
-      402 => "Payment Required",
-      403 => "Forbidden",
-      404 => "Not Found",
-      405 => "Method Not Allowed",
-      406 => "Not Acceptable",
-      407 => "Proxy Authentication Required",
-      408 => "Request Timeout",
-      409 => "Conflict",
-      410 => "Gone",
-      411 => "Length Required",
-      412 => "Precondition Failed",
-      413 => "Request Entity Too Large",
-      414 => "Request-URI Too Long",
-      415 => "Unsupported Media Type",
-      416 => "Requested Range Not Satisfiable",
-      417 => "Expectation Failed",
-      422 => "Unprocessable Entity",
-      423 => "Locked",
-      424 => "Failed Dependency",
-      426 => "Upgrade Required",
-
-      500 => "Internal Server Error",
-      501 => "Not Implemented",
-      502 => "Bad Gateway",
-      503 => "Service Unavailable",
-      504 => "Gateway Timeout",
-      505 => "HTTP Version Not Supported",
-      507 => "Insufficient Storage",
-      510 => "Not Extended"
-    }
-
-    # Provides a symbol-to-fixnum lookup for converting a symbol (like
-    # :created or :not_implemented) into its corresponding HTTP status
-    # code (like 200 or 501).
-    SYMBOL_TO_STATUS_CODE = STATUS_CODES.inject({}) do |hash, (code, message)|
-      hash[message.gsub(/ /, "").underscore.to_sym] = code
-      hash
-    end
-
-    # Given a status parameter, determine whether it needs to be converted
-    # to a string. If it is a fixnum, use the STATUS_CODES hash to lookup
-    # the default message. If it is a symbol, use the SYMBOL_TO_STATUS_CODE
-    # hash to convert it.
-    def interpret_status(status)
-      case status
-      when Fixnum then
-        "#{status} #{STATUS_CODES[status]}".strip
-      when Symbol then
-        interpret_status(SYMBOL_TO_STATUS_CODE[status] ||
-          "500 Unknown Status #{status.inspect}")
-      else
-        status.to_s
-      end
-    end
-    private :interpret_status
-
-  end
-end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/assertions/dom_assertions.rb b/actionpack/lib/action_controller/testing/assertions/dom.rb
index 5ffe5f1883..5ffe5f1883 100644
--- a/actionpack/lib/action_controller/assertions/dom_assertions.rb
+++ b/actionpack/lib/action_controller/testing/assertions/dom.rb
diff --git a/actionpack/lib/action_controller/assertions/model_assertions.rb b/actionpack/lib/action_controller/testing/assertions/model.rb
index 3a7b39b106..3a7b39b106 100644
--- a/actionpack/lib/action_controller/assertions/model_assertions.rb
+++ b/actionpack/lib/action_controller/testing/assertions/model.rb
diff --git a/actionpack/lib/action_controller/assertions/response_assertions.rb b/actionpack/lib/action_controller/testing/assertions/response.rb
index 5976090273..ca0a9bbf52 100644
--- a/actionpack/lib/action_controller/assertions/response_assertions.rb
+++ b/actionpack/lib/action_controller/testing/assertions/response.rb
@@ -11,7 +11,7 @@ module ActionController
       #
       # You can also pass an explicit status number like assert_response(501)
       # or its symbolic equivalent assert_response(:not_implemented).
-      # See ActionController::StatusCodes for a full list.
+      # See ActionDispatch::StatusCodes for a full list.
       #
       # ==== Examples
       #
@@ -27,7 +27,7 @@ module ActionController
             assert_block("") { true } # to count the assertion
           elsif type.is_a?(Fixnum) && @response.response_code == type
             assert_block("") { true } # to count the assertion
-          elsif type.is_a?(Symbol) && @response.response_code == ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
+          elsif type.is_a?(Symbol) && @response.response_code == ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
             assert_block("") { true } # to count the assertion
           else
             if @response.error?
diff --git a/actionpack/lib/action_controller/assertions/routing_assertions.rb b/actionpack/lib/action_controller/testing/assertions/routing.rb
index 5101751cea..5101751cea 100644
--- a/actionpack/lib/action_controller/assertions/routing_assertions.rb
+++ b/actionpack/lib/action_controller/testing/assertions/routing.rb
diff --git a/actionpack/lib/action_controller/assertions/selector_assertions.rb b/actionpack/lib/action_controller/testing/assertions/selector.rb
index 0d56ea5ef7..0d56ea5ef7 100644
--- a/actionpack/lib/action_controller/assertions/selector_assertions.rb
+++ b/actionpack/lib/action_controller/testing/assertions/selector.rb
diff --git a/actionpack/lib/action_controller/assertions/tag_assertions.rb b/actionpack/lib/action_controller/testing/assertions/tag.rb
index 80249e0e83..80249e0e83 100644
--- a/actionpack/lib/action_controller/assertions/tag_assertions.rb
+++ b/actionpack/lib/action_controller/testing/assertions/tag.rb
diff --git a/actionpack/lib/action_controller/integration.rb b/actionpack/lib/action_controller/testing/integration.rb
index fda6b639d1..d51b9b63ff 100644
--- a/actionpack/lib/action_controller/integration.rb
+++ b/actionpack/lib/action_controller/testing/integration.rb
@@ -323,7 +323,7 @@ module ActionController
           @html_document = nil
 
           @status = status.to_i
-          @status_message = StatusCodes::STATUS_CODES[@status]
+          @status_message = ActionDispatch::StatusCodes::STATUS_CODES[@status]
 
           @headers = Rack::Utils::HeaderHash.new(headers)
 
@@ -348,7 +348,7 @@ module ActionController
           else
             # Decorate responses from Rack Middleware and Rails Metal
             # as an Response for the purposes of integration testing
-            @response = Response.new
+            @response = ActionDispatch::Response.new
             @response.status = status.to_s
             @response.headers.replace(@headers)
             @response.body = @body_parts
@@ -387,7 +387,7 @@ module ActionController
             "SERVER_PORT"    => https? ? "443" : "80",
             "HTTPS"          => https? ? "on" : "off"
           }
-          UrlRewriter.new(Request.new(env), {})
+          UrlRewriter.new(ActionDispatch::Request.new(env), {})
         end
 
         def name_with_prefix(prefix, name)
diff --git a/actionpack/lib/action_controller/performance_test.rb b/actionpack/lib/action_controller/testing/performance.rb
index d88180087d..d88180087d 100644
--- a/actionpack/lib/action_controller/performance_test.rb
+++ b/actionpack/lib/action_controller/testing/performance.rb
diff --git a/actionpack/lib/action_controller/test_process.rb b/actionpack/lib/action_controller/testing/process.rb
index 9dd09c30b4..7e2857614c 100644
--- a/actionpack/lib/action_controller/test_process.rb
+++ b/actionpack/lib/action_controller/testing/process.rb
@@ -1,5 +1,6 @@
+require 'rack/session/abstract/id'
 module ActionController #:nodoc:
-  class TestRequest < Request #:nodoc:
+  class TestRequest < ActionDispatch::Request #:nodoc:
     attr_accessor :cookies, :session_options
     attr_accessor :query_parameters, :path, :session
     attr_accessor :host
@@ -13,6 +14,8 @@ module ActionController #:nodoc:
 
       @query_parameters   = {}
       @session            = TestSession.new
+      default_rack_options = Rack::Session::Abstract::ID::DEFAULT_OPTIONS
+      @session_options    ||= {:id => generate_sid(default_rack_options[:sidbits])}.merge(default_rack_options)
 
       initialize_default_values
       initialize_containers
@@ -110,6 +113,7 @@ module ActionController #:nodoc:
     end
 
     def recycle!
+      @env["action_controller.request.request_parameters"] = {}
       self.query_parameters   = {}
       self.path_parameters    = {}
       @headers, @request_method, @accepts, @content_type = nil, nil, nil, nil
@@ -120,6 +124,10 @@ module ActionController #:nodoc:
     end
 
     private
+      def generate_sid(sidbits)
+        "%0#{sidbits / 4}x" % rand(2**sidbits - 1)
+      end
+
       def initialize_containers
         @cookies = {}
       end
@@ -250,7 +258,7 @@ module ActionController #:nodoc:
     def cookies
       cookies = {}
       Array(headers['Set-Cookie']).each do |cookie|
-        key, value = cookie.split(";").first.split("=")
+        key, value = cookie.split(";").first.split("=").map {|val| Rack::Utils.unescape(val)}
         cookies[key] = value
       end
       cookies
@@ -275,10 +283,11 @@ module ActionController #:nodoc:
   # controller actions.
   #
   # See Response for more information on controller response objects.
-  class TestResponse < Response
+  class TestResponse < ActionDispatch::Response
     include TestResponseBehavior
 
     def recycle!
+      body_parts.clear
       headers.delete('ETag')
       headers.delete('Last-Modified')
     end
diff --git a/actionpack/lib/action_controller/test_case.rb b/actionpack/lib/action_controller/testing/test_case.rb
index d2059d51f4..b020b755a0 100644
--- a/actionpack/lib/action_controller/test_case.rb
+++ b/actionpack/lib/action_controller/testing/test_case.rb
@@ -1,5 +1,5 @@
 require 'active_support/test_case'
-require 'action_controller/test_process'
+require 'action_controller/testing/process'
 
 module ActionController
   # Superclass for ActionController functional tests. Functional tests allow you to
diff --git a/actionpack/lib/action_controller/uploaded_file.rb b/actionpack/lib/action_controller/uploaded_file.rb
deleted file mode 100644
index 376ba3621a..0000000000
--- a/actionpack/lib/action_controller/uploaded_file.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-module ActionController
-  module UploadedFile
-    def self.included(base)
-      base.class_eval do
-        attr_accessor :original_path, :content_type
-        alias_method :local_path, :path
-      end
-    end
-
-    def self.extended(object)
-      object.class_eval do
-        attr_accessor :original_path, :content_type
-        alias_method :local_path, :path
-      end
-    end
-
-    # Take the basename of the upload's original filename.
-    # This handles the full Windows paths given by Internet Explorer
-    # (and perhaps other broken user agents) without affecting
-    # those which give the lone filename.
-    # The Windows regexp is adapted from Perl's File::Basename.
-    def original_filename
-      unless defined? @original_filename
-        @original_filename =
-          unless original_path.blank?
-            if original_path =~ /^(?:.*[:\\\/])?(.*)/m
-              $1
-            else
-              File.basename original_path
-            end
-          end
-      end
-      @original_filename
-    end
-  end
-
-  class UploadedStringIO < StringIO
-    include UploadedFile
-  end
-
-  class UploadedTempfile < Tempfile
-    include UploadedFile
-  end
-end
diff --git a/actionpack/lib/action_dispatch.rb b/actionpack/lib/action_dispatch.rb
new file mode 100644
index 0000000000..bd5a38cc82
--- /dev/null
+++ b/actionpack/lib/action_dispatch.rb
@@ -0,0 +1,64 @@
+#--
+# Copyright (c) 2004-2009 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+begin
+  require 'active_support'
+rescue LoadError
+  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+  if File.directory?(activesupport_path)
+    $:.unshift activesupport_path
+    require 'active_support'
+  end
+end
+
+$:.unshift "#{File.dirname(__FILE__)}/action_dispatch/vendor/rack-1.0"
+begin
+  gem 'rack', '~> 1.0.0'
+  require 'rack'
+rescue Gem::LoadError
+  require 'action_dispatch/vendor/rack-1.0/rack'
+end
+
+module ActionDispatch
+  autoload :Request, 'action_dispatch/http/request'
+  autoload :Response, 'action_dispatch/http/response'
+  autoload :StatusCodes, 'action_dispatch/http/status_codes'
+
+  autoload :Failsafe, 'action_dispatch/middleware/failsafe'
+  autoload :ParamsParser, 'action_dispatch/middleware/params_parser'
+  autoload :Reloader, 'action_dispatch/middleware/reloader'
+  autoload :RewindableInput, 'action_dispatch/middleware/rewindable_input'
+  autoload :MiddlewareStack, 'action_dispatch/middleware/stack'
+
+  module Http
+    autoload :Headers, 'action_dispatch/http/headers'
+  end
+
+  module Session
+    autoload :AbstractStore, 'action_dispatch/middleware/session/abstract_store'
+    autoload :CookieStore, 'action_dispatch/middleware/session/cookie_store'
+    autoload :MemCacheStore, 'action_dispatch/middleware/session/mem_cache_store'
+  end
+end
+
+autoload :Mime, 'action_dispatch/http/mime_type'
diff --git a/actionpack/lib/action_controller/headers.rb b/actionpack/lib/action_dispatch/http/headers.rb
index 139669c66f..2a41b4dbad 100644
--- a/actionpack/lib/action_controller/headers.rb
+++ b/actionpack/lib/action_dispatch/http/headers.rb
@@ -1,6 +1,6 @@
 require 'active_support/memoizable'
 
-module ActionController
+module ActionDispatch
   module Http
     class Headers < ::Hash
       extend ActiveSupport::Memoizable
diff --git a/actionpack/lib/action_controller/mime_type.rb b/actionpack/lib/action_dispatch/http/mime_type.rb
index 017626ba27..02ad7f7d94 100644
--- a/actionpack/lib/action_controller/mime_type.rb
+++ b/actionpack/lib/action_dispatch/http/mime_type.rb
@@ -5,6 +5,10 @@ module Mime
   EXTENSION_LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
   LOOKUP           = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
 
+  def self.[](type)
+    Type.lookup_by_extension(type.to_s)
+  end
+
   # Encapsulates the notion of a mime type. Can be used at render time, for example, with:
   #
   #   class PostsController < ActionController::Base
@@ -27,7 +31,7 @@ module Mime
     # only needs to protect against these types.
     @@browser_generated_types = Set.new [:html, :url_encoded_form, :multipart_form, :text]
     cattr_reader :browser_generated_types
-
+    attr_reader :symbol
 
     @@unverifiable_types = Set.new [:text, :json, :csv, :xml, :rss, :atom, :yaml]
     def self.unverifiable_types
@@ -187,17 +191,13 @@ module Mime
     # Returns true if Action Pack should check requests using this Mime Type for possible request forgery.  See
     # ActionController::RequestForgeryProtection.
     def verify_request?
-      browser_generated?
+      @@browser_generated_types.include?(to_sym)
     end
 
     def html?
       @@html_types.include?(to_sym) || @string =~ /html/
     end
 
-    def browser_generated?
-      @@browser_generated_types.include?(to_sym)
-    end
-
     private
       def method_missing(method, *args)
         if method.to_s =~ /(\w+)\?$/
@@ -209,4 +209,4 @@ module Mime
   end
 end
 
-require 'action_controller/mime_types'
+require 'action_dispatch/http/mime_types'
diff --git a/actionpack/lib/action_controller/mime_types.rb b/actionpack/lib/action_dispatch/http/mime_types.rb
index 2d7fba1173..2d7fba1173 100644
--- a/actionpack/lib/action_controller/mime_types.rb
+++ b/actionpack/lib/action_dispatch/http/mime_types.rb
diff --git a/actionpack/lib/action_controller/request.rb b/actionpack/lib/action_dispatch/http/request.rb
index ef223f157c..523ab32b35 100755
--- a/actionpack/lib/action_controller/request.rb
+++ b/actionpack/lib/action_dispatch/http/request.rb
@@ -3,9 +3,8 @@ require 'stringio'
 require 'strscan'
 
 require 'active_support/memoizable'
-require 'action_controller/cgi_ext'
 
-module ActionController
+module ActionDispatch
   class Request < Rack::Request
 
     %w[ AUTH_TYPE GATEWAY_INTERFACE
@@ -32,7 +31,7 @@ module ActionController
     # <tt>:get</tt>. If the request \method is not listed in the HTTP_METHODS
     # constant above, an UnknownHttpMethod exception is raised.
     def request_method
-      @request_method ||= HTTP_METHOD_LOOKUP[super] || raise(UnknownHttpMethod, "#{super}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
+      @request_method ||= HTTP_METHOD_LOOKUP[super] || raise(ActionController::UnknownHttpMethod, "#{super}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
     end
 
     # Returns the HTTP request \method used for action processing as a
@@ -73,7 +72,7 @@ module ActionController
     #
     #   request.headers["Content-Type"] # => "text/plain"
     def headers
-      @headers ||= ActionController::Http::Headers.new(@env)
+      Http::Headers.new(@env)
     end
 
     # Returns the content length of the request as an integer.
@@ -94,20 +93,26 @@ module ActionController
         end
       end
     end
-
+    
     # Returns the accepted MIME type for the request.
     def accepts
       @accepts ||= begin
         header = @env['HTTP_ACCEPT'].to_s.strip
 
+        fallback = xhr? ? Mime::JS : Mime::HTML
+
         if header.empty?
-          [content_type, Mime::ALL].compact
+          [content_type, fallback, Mime::ALL].compact
         else
-          Mime::Type.parse(header)
+          ret = Mime::Type.parse(header)
+          if ret.last == Mime::ALL
+            ret.insert(-2, fallback)
+          end
+          ret
         end
       end
     end
-
+    
     def if_modified_since
       if since = env['HTTP_IF_MODIFIED_SINCE']
         Time.rfc2822(since) rescue nil
@@ -142,24 +147,33 @@ module ActionController
       end
     end
 
+    ONLY_ALL = [Mime::ALL].freeze
+
     # Returns the Mime type for the \format used in the request.
     #
     #   GET /posts/5.xml   | request.format => Mime::XML
     #   GET /posts/5.xhtml | request.format => Mime::HTML
     #   GET /posts/5       | request.format => Mime::HTML or MIME::JS, or request.accepts.first depending on the value of <tt>ActionController::Base.use_accept_header</tt>
-    def format
+
+    def format(view_path = [])
       @format ||=
         if parameters[:format]
-          Mime::Type.lookup_by_extension(parameters[:format])
-        elsif ActionController::Base.use_accept_header
-          accepts.first
-        elsif xhr?
-          Mime::Type.lookup_by_extension("js")
-        else
-          Mime::Type.lookup_by_extension("html")
+                        Mime[parameters[:format]]
+        elsif ActionController::Base.use_accept_header && !(accepts == ONLY_ALL)
+                        accepts.first
+        elsif xhr? then Mime::JS
+        else            Mime::HTML
         end
     end
 
+    def formats
+      @formats = 
+        if ActionController::Base.use_accept_header
+          Array(Mime[parameters[:format]] || accepts)
+        else
+          [format]
+        end
+    end
 
     # Sets the \format by string extension, which can be used to force custom formats
     # that are not controlled by the extension.
@@ -226,7 +240,7 @@ module ActionController
       if @env.include? 'HTTP_CLIENT_IP'
         if ActionController::Base.ip_spoofing_check && remote_ips && !remote_ips.include?(@env['HTTP_CLIENT_IP'])
           # We don't know which came from the proxy, and which from the user
-          raise ActionControllerError.new(<<EOM)
+          raise ActionController::ActionControllerError.new(<<EOM)
 IP spoofing attack?!
 HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect}
 HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}
@@ -463,6 +477,34 @@ EOM
         !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
       end
 
+      module UploadedFile
+        def self.extended(object)
+          object.class_eval do
+            attr_accessor :original_path, :content_type
+            alias_method :local_path, :path
+          end
+        end
+
+        # Take the basename of the upload's original filename.
+        # This handles the full Windows paths given by Internet Explorer
+        # (and perhaps other broken user agents) without affecting
+        # those which give the lone filename.
+        # The Windows regexp is adapted from Perl's File::Basename.
+        def original_filename
+          unless defined? @original_filename
+            @original_filename =
+              unless original_path.blank?
+                if original_path =~ /^(?:.*[:\\\/])?(.*)/m
+                  $1
+                else
+                  File.basename original_path
+                end
+              end
+          end
+          @original_filename
+        end
+      end
+
       # Convert nested Hashs to HashWithIndifferentAccess and replace
       # file upload hashs with UploadedFile objects
       def normalize_parameters(value)
diff --git a/actionpack/lib/action_controller/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index febe4ccf29..ecf40b8103 100644
--- a/actionpack/lib/action_controller/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -1,6 +1,6 @@
 require 'digest/md5'
 
-module ActionController # :nodoc:
+module ActionDispatch # :nodoc:
   # Represents an HTTP response generated by a controller action. One can use
   # an ActionController::Response object to retrieve the current state
   # of the response, or customize the response. An Response object can
diff --git a/actionpack/lib/action_dispatch/http/status_codes.rb b/actionpack/lib/action_dispatch/http/status_codes.rb
new file mode 100644
index 0000000000..830de2a6db
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/status_codes.rb
@@ -0,0 +1,40 @@
+module ActionDispatch
+  module StatusCodes #:nodoc:
+    STATUS_CODES = Rack::Utils::HTTP_STATUS_CODES.merge({
+      102 => "Processing",
+      207 => "Multi-Status",
+      226 => "IM Used",
+      422 => "Unprocessable Entity",
+      423 => "Locked",
+      424 => "Failed Dependency",
+      426 => "Upgrade Required",
+      507 => "Insufficient Storage",
+      510 => "Not Extended"
+    }).freeze
+
+    # Provides a symbol-to-fixnum lookup for converting a symbol (like
+    # :created or :not_implemented) into its corresponding HTTP status
+    # code (like 200 or 501).
+    SYMBOL_TO_STATUS_CODE = STATUS_CODES.inject({}) { |hash, (code, message)|
+      hash[message.gsub(/ /, "").underscore.to_sym] = code
+      hash
+    }.freeze
+
+    private
+      # Given a status parameter, determine whether it needs to be converted
+      # to a string. If it is a fixnum, use the STATUS_CODES hash to lookup
+      # the default message. If it is a symbol, use the SYMBOL_TO_STATUS_CODE
+      # hash to convert it.
+      def interpret_status(status)
+        case status
+        when Fixnum then
+          "#{status} #{STATUS_CODES[status]}".strip
+        when Symbol then
+          interpret_status(SYMBOL_TO_STATUS_CODE[status] ||
+            "500 Unknown Status #{status.inspect}")
+        else
+          status.to_s
+        end
+      end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/failsafe.rb b/actionpack/lib/action_dispatch/middleware/failsafe.rb
index 567581142c..7379a696aa 100644
--- a/actionpack/lib/action_controller/failsafe.rb
+++ b/actionpack/lib/action_dispatch/middleware/failsafe.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   class Failsafe
     cattr_accessor :error_file_path
     self.error_file_path = Rails.public_path if defined?(Rails.public_path)
diff --git a/actionpack/lib/action_controller/params_parser.rb b/actionpack/lib/action_dispatch/middleware/params_parser.rb
index d269fe07fa..6df572268c 100644
--- a/actionpack/lib/action_controller/params_parser.rb
+++ b/actionpack/lib/action_dispatch/middleware/params_parser.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   class ParamsParser
     ActionController::Base.param_parsers[Mime::XML] = :xml_simple
     ActionController::Base.param_parsers[Mime::JSON] = :json
diff --git a/actionpack/lib/action_controller/reloader.rb b/actionpack/lib/action_dispatch/middleware/reloader.rb
index 46789309cd..67313e30e4 100644
--- a/actionpack/lib/action_controller/reloader.rb
+++ b/actionpack/lib/action_dispatch/middleware/reloader.rb
@@ -1,14 +1,14 @@
-module ActionController
+module ActionDispatch
   class Reloader
     def initialize(app)
       @app = app
     end
 
     def call(env)
-      Dispatcher.reload_application
+      ActionController::Dispatcher.reload_application
       @app.call(env)
     ensure
-      Dispatcher.cleanup_application
+      ActionController::Dispatcher.cleanup_application
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/rewindable_input.rb b/actionpack/lib/action_dispatch/middleware/rewindable_input.rb
new file mode 100644
index 0000000000..c818f28cce
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/rewindable_input.rb
@@ -0,0 +1,19 @@
+module ActionDispatch
+  class RewindableInput
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        env['rack.input'].rewind
+      rescue NoMethodError, Errno::ESPIPE
+        # Handles exceptions raised by input streams that cannot be rewound
+        # such as when using plain CGI under Apache
+        env['rack.input'] = StringIO.new(env['rack.input'].read)
+      end
+
+      @app.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/session/abstract_store.rb b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
index f6369abf15..6c039cf62d 100644
--- a/actionpack/lib/action_controller/session/abstract_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
@@ -1,6 +1,6 @@
 require 'rack/utils'
 
-module ActionController
+module ActionDispatch
   module Session
     class AbstractStore
       ENV_SESSION_KEY = 'rack.session'.freeze
diff --git a/actionpack/lib/action_controller/session/cookie_store.rb b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
index a2543c1824..433c4cc070 100644
--- a/actionpack/lib/action_controller/session/cookie_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Session
     # This cookie-based session store is the Rails default. Sessions typically
     # contain at most a user_id and flash message; both fit within the 4K cookie
diff --git a/actionpack/lib/action_controller/session/mem_cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
index f745715a97..8f448970d9 100644
--- a/actionpack/lib/action_controller/session/mem_cache_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
@@ -1,7 +1,7 @@
 begin
   require_library_or_gem 'memcache'
 
-  module ActionController
+  module ActionDispatch
     module Session
       class MemCacheStore < AbstractStore
         def initialize(app, options = {})
diff --git a/actionpack/lib/action_controller/middleware_stack.rb b/actionpack/lib/action_dispatch/middleware/stack.rb
index b739a6d72d..ee5f28d5cb 100644
--- a/actionpack/lib/action_controller/middleware_stack.rb
+++ b/actionpack/lib/action_dispatch/middleware/stack.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   class MiddlewareStack < Array
     class Middleware
       def self.new(klass, *args, &block)
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack.rb
index 6349b95094..6349b95094 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/adapter/camping.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/adapter/camping.rb
index 63bc787f54..63bc787f54 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/adapter/camping.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/adapter/camping.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/abstract/handler.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/handler.rb
index 214df6299e..214df6299e 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/abstract/handler.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/handler.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/abstract/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/request.rb
index 1d9ccec685..1d9ccec685 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/abstract/request.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/request.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/basic.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/basic.rb
index 9557224648..9557224648 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/basic.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/basic.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/md5.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/md5.rb
index e579dc9632..e579dc9632 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/md5.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/md5.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/nonce.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/nonce.rb
index dbe109f29a..dbe109f29a 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/nonce.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/nonce.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/params.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/params.rb
index 730e2efdc8..730e2efdc8 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/params.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/params.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/request.rb
index a8aa3bf996..a8aa3bf996 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/digest/request.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/request.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/openid.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/openid.rb
index c5f6a5143e..c5f6a5143e 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/auth/openid.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/openid.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/builder.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/builder.rb
index 295235e56a..295235e56a 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/builder.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/builder.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/cascade.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/cascade.rb
index a038aa1105..a038aa1105 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/cascade.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/cascade.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/chunked.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/chunked.rb
index 280d89dd65..280d89dd65 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/chunked.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/chunked.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/commonlogger.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/commonlogger.rb
index 5e68ac626d..5e68ac626d 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/commonlogger.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/commonlogger.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/conditionalget.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/conditionalget.rb
index 7bec824181..7bec824181 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/conditionalget.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/conditionalget.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/content_length.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_length.rb
index 1e56d43853..1e56d43853 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/content_length.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_length.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/content_type.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_type.rb
index 0c1e1ca3e1..0c1e1ca3e1 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/content_type.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_type.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/deflater.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/deflater.rb
index a42b7477ae..a42b7477ae 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/deflater.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/deflater.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/directory.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/directory.rb
index acdd3029d3..acdd3029d3 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/directory.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/directory.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/file.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/file.rb
index fe62bd6b86..fe62bd6b86 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/file.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/file.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler.rb
index 1018af64c7..1018af64c7 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/cgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/cgi.rb
index e38156c7f0..e38156c7f0 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/cgi.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/cgi.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/evented_mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/evented_mongrel.rb
index 0f5cbf7293..0f5cbf7293 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/evented_mongrel.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/evented_mongrel.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/fastcgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/fastcgi.rb
index 6324c7d274..6324c7d274 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/fastcgi.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/fastcgi.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/lsws.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/lsws.rb
index c65ba3ec8e..c65ba3ec8e 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/lsws.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/lsws.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/mongrel.rb
index f0c0d58330..f0c0d58330 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/mongrel.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/mongrel.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/scgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/scgi.rb
index 9495c66374..9495c66374 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/scgi.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/scgi.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/swiftiplied_mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/swiftiplied_mongrel.rb
index 4bafd0b953..4bafd0b953 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/swiftiplied_mongrel.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/swiftiplied_mongrel.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/thin.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/thin.rb
index 3d4fedff75..3d4fedff75 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/thin.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/thin.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/webrick.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/webrick.rb
index 829e7d6bf8..829e7d6bf8 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/handler/webrick.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/webrick.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/head.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/head.rb
index deab822a99..deab822a99 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/head.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/head.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/lint.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lint.rb
index 44a33ce36e..44a33ce36e 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/lint.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lint.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/lobster.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lobster.rb
index f63f419a49..f63f419a49 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/lobster.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lobster.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/lock.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lock.rb
index 93238528c4..93238528c4 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/lock.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lock.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/methodoverride.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/methodoverride.rb
index 0eed29f471..0eed29f471 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/methodoverride.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/methodoverride.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/mime.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mime.rb
index 5a6a73a97b..5a6a73a97b 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/mime.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mime.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/mock.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mock.rb
index 70852da3db..70852da3db 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/mock.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mock.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/recursive.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/recursive.rb
index bf8b965925..bf8b965925 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/recursive.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/recursive.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/reloader.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/reloader.rb
index b17d8c0926..b17d8c0926 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/reloader.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/reloader.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/request.rb
index d77fa26575..d77fa26575 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/request.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/request.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/response.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/response.rb
index caf60d5b19..caf60d5b19 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/response.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/response.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/abstract/id.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/abstract/id.rb
index 218144c17f..218144c17f 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/abstract/id.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/abstract/id.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/cookie.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/cookie.rb
index eace9bd0c6..eace9bd0c6 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/cookie.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/cookie.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/memcache.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/memcache.rb
index 4a65cbf35d..4a65cbf35d 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/memcache.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/memcache.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/pool.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/pool.rb
index f6f87408bb..f6f87408bb 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/session/pool.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/pool.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/showexceptions.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showexceptions.rb
index 697bc41fdb..697bc41fdb 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/showexceptions.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showexceptions.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/showstatus.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showstatus.rb
index 28258c7c89..28258c7c89 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/showstatus.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showstatus.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/static.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/static.rb
index 168e8f83b2..168e8f83b2 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/static.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/static.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/urlmap.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/urlmap.rb
index 0ff32df181..0ff32df181 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/urlmap.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/urlmap.rb
diff --git a/actionpack/lib/action_controller/vendor/rack-1.0/rack/utils.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/utils.rb
index 0a61bce707..0a61bce707 100644
--- a/actionpack/lib/action_controller/vendor/rack-1.0/rack/utils.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/utils.rb
diff --git a/actionpack/lib/action_view.rb b/actionpack/lib/action_view.rb
index 1f1ff9dd05..e604c2a581 100644
--- a/actionpack/lib/action_view.rb
+++ b/actionpack/lib/action_view.rb
@@ -31,6 +31,8 @@ rescue LoadError
   end
 end
 
+require File.join(File.dirname(__FILE__), "action_pack")
+
 module ActionView
   def self.load_all!
     [Base, InlineTemplate, TemplateError]
@@ -38,16 +40,18 @@ module ActionView
 
   autoload :Base, 'action_view/base'
   autoload :Helpers, 'action_view/helpers'
-  autoload :InlineTemplate, 'action_view/inline_template'
-  autoload :Partials, 'action_view/partials'
+  autoload :InlineTemplate, 'action_view/template/inline'
+  autoload :Partials, 'action_view/render/partials'
+  autoload :Path, 'action_view/template/path'
   autoload :PathSet, 'action_view/paths'
-  autoload :Renderable, 'action_view/renderable'
-  autoload :RenderablePartial, 'action_view/renderable_partial'
-  autoload :Template, 'action_view/template'
-  autoload :ReloadableTemplate, 'action_view/reloadable_template'
-  autoload :TemplateError, 'action_view/template_error'
-  autoload :TemplateHandler, 'action_view/template_handler'
-  autoload :TemplateHandlers, 'action_view/template_handlers'
+  autoload :Rendering, 'action_view/render/rendering'
+  autoload :Renderable, 'action_view/template/renderable'
+  autoload :RenderablePartial, 'action_view/template/partial'
+  autoload :Template, 'action_view/template/template'
+  autoload :TemplateError, 'action_view/template/error'
+  autoload :TemplateHandler, 'action_view/template/handler'
+  autoload :TemplateHandlers, 'action_view/template/handlers'
+  autoload :TextTemplate, 'action_view/template/text'
   autoload :Helpers, 'action_view/helpers'
 end
 
diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb
index 9c0134e7f7..efed19a21d 100644
--- a/actionpack/lib/action_view/base.rb
+++ b/actionpack/lib/action_view/base.rb
@@ -3,10 +3,11 @@ module ActionView #:nodoc:
   end
 
   class MissingTemplate < ActionViewError #:nodoc:
-    attr_reader :path
+    attr_reader :path, :action_name
 
     def initialize(paths, path, template_format = nil)
       @path = path
+      @action_name = path.split("/").last.split(".")[0...-1].join(".")
       full_template_path = path.include?('.') ? path : "#{path}.erb"
       display_paths = paths.compact.join(":")
       template_type = (path =~ /layouts/i) ? 'layout' : 'template'
@@ -160,14 +161,13 @@ module ActionView #:nodoc:
   #
   # See the ActionView::Helpers::PrototypeHelper::GeneratorMethods documentation for more details.
   class Base
-    include Helpers, Partials, ::ERB::Util
+    include Helpers, Rendering, Partials, ::ERB::Util
+
     extend ActiveSupport::Memoizable
 
-    attr_accessor :base_path, :assigns, :template_extension
+    attr_accessor :base_path, :assigns, :template_extension, :formats
     attr_accessor :controller
 
-    attr_writer :template_format
-
     attr_accessor :output_buffer
 
     class << self
@@ -193,9 +193,13 @@ module ActionView #:nodoc:
 
     attr_internal :request
 
+    delegate :controller_path, :to => :controller, :allow_nil => true
+
     delegate :request_forgery_protection_token, :template, :params, :session, :cookies, :response, :headers,
              :flash, :logger, :action_name, :controller_name, :to => :controller
 
+    delegate :find_by_parts, :to => :view_paths
+
     module CompiledTemplates #:nodoc:
       # holds compiled template code
     end
@@ -218,7 +222,8 @@ module ActionView #:nodoc:
       end
     end
 
-    def initialize(view_paths = [], assigns_for_first_render = {}, controller = nil)#:nodoc:
+    def initialize(view_paths = [], assigns_for_first_render = {}, controller = nil, formats = nil)#:nodoc:
+      @formats = formats || [:html]
       @assigns = assigns_for_first_render
       @assigns_added = nil
       @controller = controller
@@ -233,56 +238,6 @@ module ActionView #:nodoc:
 
     def view_paths=(paths)
       @view_paths = self.class.process_view_paths(paths)
-      # we might be using ReloadableTemplates, so we need to let them know this a new request
-      @view_paths.load!
-    end
-
-    # Returns the result of a render that's dictated by the options hash. The primary options are:
-    #
-    # * <tt>:partial</tt> - See ActionView::Partials.
-    # * <tt>:update</tt> - Calls update_page with the block given.
-    # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
-    # * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.
-    # * <tt>:text</tt> - Renders the text passed in out.
-    #
-    # If no options hash is passed or :update specified, the default is to render a partial and use the second parameter
-    # as the locals hash.
-    def render(options = {}, local_assigns = {}, &block) #:nodoc:
-      local_assigns ||= {}
-
-      case options
-      when Hash
-        options = options.reverse_merge(:locals => {})
-        if options[:layout]
-          _render_with_layout(options, local_assigns, &block)
-        elsif options[:file]
-          template = self.view_paths.find_template(options[:file], template_format)
-          template.render_template(self, options[:locals])
-        elsif options[:partial]
-          render_partial(options)
-        elsif options[:inline]
-          InlineTemplate.new(options[:inline], options[:type]).render(self, options[:locals])
-        elsif options[:text]
-          options[:text]
-        end
-      when :update
-        update_page(&block)
-      else
-        render_partial(:partial => options, :locals => local_assigns)
-      end
-    end
-
-    # The format to be used when choosing between multiple templates with
-    # the same name but differing formats.  See +Request#template_format+
-    # for more details.
-    def template_format
-      if defined? @template_format
-        @template_format
-      elsif controller && controller.respond_to?(:request)
-        @template_format = controller.request.template_format.to_sym
-      else
-        @template_format = :html
-      end
     end
 
     # Access the current template being rendered.
@@ -332,32 +287,5 @@ module ActionView #:nodoc:
           controller.response.content_type ||= content_type
         end
       end
-
-      def _render_with_layout(options, local_assigns, &block) #:nodoc:
-        partial_layout = options.delete(:layout)
-
-        if block_given?
-          begin
-            @_proc_for_layout = block
-            concat(render(options.merge(:partial => partial_layout)))
-          ensure
-            @_proc_for_layout = nil
-          end
-        else
-          begin
-            original_content_for_layout = @content_for_layout if defined?(@content_for_layout)
-            @content_for_layout = render(options)
-
-            if (options[:inline] || options[:file] || options[:text])
-              @cached_content_for_layout = @content_for_layout
-              render(:file => partial_layout, :locals => local_assigns)
-            else
-              render(options.merge(:partial => partial_layout))
-            end
-          ensure
-            @content_for_layout = original_content_for_layout
-          end
-        end
-      end
   end
 end
diff --git a/actionpack/lib/action_view/helpers/active_record_helper.rb b/actionpack/lib/action_view/helpers/active_record_helper.rb
index 541899ea6a..7c0dfdab10 100644
--- a/actionpack/lib/action_view/helpers/active_record_helper.rb
+++ b/actionpack/lib/action_view/helpers/active_record_helper.rb
@@ -194,7 +194,7 @@ module ActionView
               options[:header_message]
             else
               object_name = options[:object_name].to_s.gsub('_', ' ')
-              object_name = I18n.t(object_name, :default => object_name, :scope => [:activerecord, :models], :count => 1)
+              object_name = I18n.t(options[:object_name].to_s, :default => object_name, :scope => [:activerecord, :models], :count => 1)
               locale.t :header, :count => count, :model => object_name
             end
             message = options.include?(:message) ? options[:message] : locale.t(:body)
diff --git a/actionpack/lib/action_view/helpers/date_helper.rb b/actionpack/lib/action_view/helpers/date_helper.rb
index c74909a360..72fe9a3232 100644
--- a/actionpack/lib/action_view/helpers/date_helper.rb
+++ b/actionpack/lib/action_view/helpers/date_helper.rb
@@ -106,8 +106,8 @@ module ActionView
       alias_method :distance_of_time_in_words_to_now, :time_ago_in_words
 
       # Returns a set of select tags (one for year, month, and day) pre-selected for accessing a specified date-based
-      # attribute (identified by +method+) on an object assigned to the template (identified by +object+). You can
-      # the output in the +options+ hash.
+      # attribute (identified by +method+) on an object assigned to the template (identified by +object+).
+      #
       #
       # ==== Options
       # * <tt>:use_month_numbers</tt> - Set to true if you want to use month numbers rather than month names (e.g.
@@ -232,7 +232,7 @@ module ActionView
 
       # Returns a set of select tags (one for year, month, day, hour, and minute) pre-selected for accessing a
       # specified datetime-based attribute (identified by +method+) on an object assigned to the template (identified
-      # by +object+). Examples:
+      # by +object+).
       #
       # If anything is passed in the html_options hash it will be applied to every select tag in the set.
       #
diff --git a/actionpack/lib/action_view/helpers/form_helper.rb b/actionpack/lib/action_view/helpers/form_helper.rb
index a589bcba2a..a59829b23f 100644
--- a/actionpack/lib/action_view/helpers/form_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_helper.rb
@@ -628,7 +628,7 @@ module ActionView
       #
       # The HTML specification says unchecked check boxes are not successful, and
       # thus web browsers do not send them. Unfortunately this introduces a gotcha:
-      # if an Invoice model has a +paid+ flag, and in the form that edits a paid
+      # if an +Invoice+ model has a +paid+ flag, and in the form that edits a paid
       # invoice the user unchecks its check box, no +paid+ parameter is sent. So,
       # any mass-assignment idiom like
       #
@@ -636,12 +636,15 @@ module ActionView
       #
       # wouldn't update the flag.
       #
-      # To prevent this the helper generates a hidden field with the same name as
-      # the checkbox after the very check box. So, the client either sends only the
-      # hidden field (representing the check box is unchecked), or both fields.
-      # Since the HTML specification says key/value pairs have to be sent in the
-      # same order they appear in the form and Rails parameters extraction always
-      # gets the first occurrence of any given key, that works in ordinary forms.
+      # To prevent this the helper generates an auxiliary hidden field before
+      # the very check box. The hidden field has the same name and its
+      # attributes mimick an unchecked check box.
+      #
+      # This way, the client either sends only the hidden field (representing
+      # the check box is unchecked), or both fields. Since the HTML specification
+      # says key/value pairs have to be sent in the same order they appear in the
+      # form, and parameters extraction gets the last occurrence of any repeated
+      # key in the query string, that works for ordinary forms.
       #
       # Unfortunately that workaround does not work when the check box goes
       # within an array-like parameter, as in
@@ -652,22 +655,26 @@ module ActionView
       #   <% end %>
       #
       # because parameter name repetition is precisely what Rails seeks to distinguish
-      # the elements of the array.
+      # the elements of the array. For each item with a checked check box you
+      # get an extra ghost item with only that attribute, assigned to "0".
+      #
+      # In that case it is preferable to either use +check_box_tag+ or to use
+      # hashes instead of arrays.
       #
       # ==== Examples
       #   # Let's say that @post.validated? is 1:
       #   check_box("post", "validated")
-      #   # => <input type="checkbox" id="post_validated" name="post[validated]" value="1" />
-      #   #    <input name="post[validated]" type="hidden" value="0" />
+      #   # => <input name="post[validated]" type="hidden" value="0" />
+      #   #    <input type="checkbox" id="post_validated" name="post[validated]" value="1" />
       #
       #   # Let's say that @puppy.gooddog is "no":
       #   check_box("puppy", "gooddog", {}, "yes", "no")
-      #   # => <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
-      #   #    <input name="puppy[gooddog]" type="hidden" value="no" />
+      #   # => <input name="puppy[gooddog]" type="hidden" value="no" />
+      #   #    <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
       #
       #   check_box("eula", "accepted", { :class => 'eula_check' }, "yes", "no")
-      #   # => <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
-      #   #    <input name="eula[accepted]" type="hidden" value="no" />
+      #   # => <input name="eula[accepted]" type="hidden" value="no" />
+      #   #    <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
       #
       def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
         InstanceTag.new(object_name, method, self, options.delete(:object)).to_check_box_tag(options, checked_value, unchecked_value)
diff --git a/actionpack/lib/action_view/helpers/form_tag_helper.rb b/actionpack/lib/action_view/helpers/form_tag_helper.rb
index 6d39a53adc..daf38fe3da 100644
--- a/actionpack/lib/action_view/helpers/form_tag_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_tag_helper.rb
@@ -406,7 +406,7 @@ module ActionView
       # <tt>legend</tt> will become the fieldset's title (optional as per W3C).
       # <tt>options</tt> accept the same values as tag.
       #
-      # === Examples
+      # ==== Examples
       #   <% field_set_tag do %>
       #     <p><%= text_field_tag 'name' %></p>
       #   <% end %>
diff --git a/actionpack/lib/action_view/helpers/prototype_helper.rb b/actionpack/lib/action_view/helpers/prototype_helper.rb
index 91ef72e54b..6bad11e354 100644
--- a/actionpack/lib/action_view/helpers/prototype_helper.rb
+++ b/actionpack/lib/action_view/helpers/prototype_helper.rb
@@ -987,13 +987,13 @@ module ActionView
             end
 
             def render(*options_for_render)
-              old_format = @context && @context.template_format
-              @context.template_format = :html if @context
+              old_formats = @context && @context.formats
+              @context.formats = [:html] if @context
               Hash === options_for_render.first ?
                 @context.render(*options_for_render) :
                   options_for_render.first.to_s
             ensure
-              @context.template_format = old_format if @context
+              @context.formats = old_formats if @context
             end
 
             def javascript_object_for(object)
diff --git a/actionpack/lib/action_view/helpers/text_helper.rb b/actionpack/lib/action_view/helpers/text_helper.rb
index 48bf4717ad..573b99b96e 100644
--- a/actionpack/lib/action_view/helpers/text_helper.rb
+++ b/actionpack/lib/action_view/helpers/text_helper.rb
@@ -324,7 +324,7 @@ module ActionView
 
       # Turns all URLs and e-mail addresses into clickable links. The <tt>:link</tt> option
       # will limit what should be linked. You can add HTML attributes to the links using
-      # <tt>:href_options</tt>. Possible values for <tt>:link</tt> are <tt>:all</tt> (default),
+      # <tt>:html</tt>. Possible values for <tt>:link</tt> are <tt>:all</tt> (default),
       # <tt>:email_addresses</tt>, and <tt>:urls</tt>. If a block is given, each URL and
       # e-mail address is yielded and the result is used as the link text.
       #
@@ -341,7 +341,7 @@ module ActionView
       #   # => "Visit http://www.loudthinking.com/ or e-mail <a href=\"mailto:david@loudthinking.com\">david@loudthinking.com</a>"
       #
       #   post_body = "Welcome to my new blog at http://www.myblog.com/.  Please e-mail me at me@email.com."
-      #   auto_link(post_body, :href_options => { :target => '_blank' }) do |text|
+      #   auto_link(post_body, :html => { :target => '_blank' }) do |text|
       #     truncate(text, 15)
       #   end
       #   # => "Welcome to my new blog at <a href=\"http://www.myblog.com/\" target=\"_blank\">http://www.m...</a>.
@@ -359,7 +359,7 @@ module ActionView
       #   auto_link(post_body, :all, :target => "_blank")     # => Once upon\na time
       #   # => "Welcome to my new blog at <a href=\"http://www.myblog.com/\" target=\"_blank\">http://www.myblog.com</a>.
       #         Please e-mail me at <a href=\"mailto:me@email.com\">me@email.com</a>."
-      def auto_link(text, *args, &block)#link = :all, href_options = {}, &block)
+      def auto_link(text, *args, &block)#link = :all, html = {}, &block)
         return '' if text.blank?
 
         options = args.size == 2 ? {} : args.extract_options! # this is necessary because the old auto_link API has a Hash as its last parameter
diff --git a/actionpack/lib/action_view/paths.rb b/actionpack/lib/action_view/paths.rb
index 8cc3fe291c..1d0279889c 100644
--- a/actionpack/lib/action_view/paths.rb
+++ b/actionpack/lib/action_view/paths.rb
@@ -2,16 +2,13 @@ module ActionView #:nodoc:
   class PathSet < Array #:nodoc:
     def self.type_cast(obj)
       if obj.is_a?(String)
-        if Base.cache_template_loading?
-          Template::EagerPath.new(obj.to_s)
-        else
-          ReloadableTemplate::ReloadablePath.new(obj.to_s)
-        end
+        cache = !Object.const_defined?(:Rails) || Rails.configuration.cache_classes
+        Template::FileSystemPath.new(obj, :cache => cache)
       else
         obj
       end
     end
-    
+
     def initialize(*args)
       super(*args).map! { |obj| self.class.type_cast(obj) }
     end
@@ -35,9 +32,29 @@ module ActionView #:nodoc:
     def unshift(*objs)
       super(*objs.map { |obj| self.class.type_cast(obj) })
     end
+
+    def find_by_parts(path, extension = nil, prefix = nil, partial = false)
+      template_path = path.sub(/^\//, '')
+
+      each do |load_path|
+        if template = load_path.find_by_parts(template_path, extension, prefix, partial)
+          return template
+        end
+      end
+
+      Template.new(path, self)
+    rescue ActionView::MissingTemplate => e
+      extension ||= []
+      raise ActionView::MissingTemplate.new(self, "#{prefix}/#{path}.{#{extension.join(",")}}")
+    end
     
-    def load!
-      each(&:load!)
+    def find_by_parts?(path, extension = nil, prefix = nil, partial = false)
+      template_path = path.sub(/^\//, '')
+
+      each do |load_path|
+        return true if template = load_path.find_by_parts(template_path, extension, prefix, partial)
+      end      
+      false
     end
 
     def find_template(original_template_path, format = nil, html_fallback = true)
@@ -45,13 +62,7 @@ module ActionView #:nodoc:
       template_path = original_template_path.sub(/^\//, '')
 
       each do |load_path|
-        if format && (template = load_path["#{template_path}.#{I18n.locale}.#{format}"])
-          return template
-        elsif format && (template = load_path["#{template_path}.#{format}"])
-          return template
-        elsif template = load_path["#{template_path}.#{I18n.locale}"]
-          return template
-        elsif template = load_path[template_path]
+        if template = load_path.find_by_parts(template_path, format)
           return template
         # Try to find html version if the format is javascript
         elsif format == :js && html_fallback && template = load_path["#{template_path}.#{I18n.locale}.html"]
diff --git a/actionpack/lib/action_view/reloadable_template.rb b/actionpack/lib/action_view/reloadable_template.rb
deleted file mode 100644
index 5ef833d75c..0000000000
--- a/actionpack/lib/action_view/reloadable_template.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-module ActionView #:nodoc:
-  class ReloadableTemplate < Template
-
-    class TemplateDeleted < ActionView::ActionViewError
-    end
-
-    class ReloadablePath < Template::Path
-
-      def initialize(path)
-        super
-        @paths = {}
-        new_request!
-      end
-
-      def new_request!
-        @disk_cache = {}
-      end
-      alias_method :load!, :new_request!
-
-      def [](path)
-        if found_template = @paths[path]
-          begin
-            found_template.reset_cache_if_stale!
-          rescue TemplateDeleted
-            unregister_template(found_template)
-            self[path]
-          end
-        else
-          load_all_templates_from_dir(templates_dir_from_path(path))
-          # don't ever hand out a template without running a stale check
-          (new_template = @paths[path]) && new_template.reset_cache_if_stale!
-        end
-      end
-
-      private
-        def register_template_from_file(template_full_file_path)
-          if !@paths[relative_path = relative_path_for_template_file(template_full_file_path)] && File.file?(template_full_file_path)
-            register_template(ReloadableTemplate.new(relative_path, self))
-          end
-        end
-
-        def register_template(template)
-          template.accessible_paths.each do |path|
-            @paths[path] = template
-          end
-        end
-
-        # remove (probably deleted) template from cache
-        def unregister_template(template)
-          template.accessible_paths.each do |template_path|
-            @paths.delete(template_path) if @paths[template_path] == template
-          end
-          # fill in any newly created gaps
-          @paths.values.uniq.each do |template|
-            template.accessible_paths.each {|path| @paths[path] ||= template}
-          end
-        end
-
-        # load all templates from the directory of the requested template
-        def load_all_templates_from_dir(dir)
-          # hit disk only once per template-dir/request
-          @disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
-        end
-
-        def templates_dir_from_path(path)
-          dirname = File.dirname(path)
-          File.join(@path, dirname == '.' ? '' : dirname)
-        end
-
-        # get all the template filenames from the dir
-        def template_files_from_dir(dir)
-          Dir.glob(File.join(dir, '*'))
-        end
-    end
-
-    module Unfreezable
-      def freeze; self; end
-    end
-
-    def initialize(*args)
-      super
-      
-      # we don't ever want to get frozen
-      extend Unfreezable
-    end
-
-    def mtime
-      File.mtime(filename)
-    end
-
-    attr_accessor :previously_last_modified
-
-    def stale?
-      previously_last_modified.nil? || previously_last_modified < mtime
-    rescue Errno::ENOENT => e
-      undef_my_compiled_methods!
-      raise TemplateDeleted
-    end
-
-    def reset_cache_if_stale!
-      if stale?
-        flush_cache 'source', 'compiled_source'
-        undef_my_compiled_methods!
-        @previously_last_modified = mtime
-      end
-      self
-    end
-
-    # remove any compiled methods that look like they might belong to me
-    def undef_my_compiled_methods!
-      ActionView::Base::CompiledTemplates.public_instance_methods.grep(/#{Regexp.escape(method_name_without_locals)}(?:_locals_)?/).each do |m|
-        ActionView::Base::CompiledTemplates.send(:remove_method, m)
-      end
-    end
-
-  end
-end
diff --git a/actionpack/lib/action_view/partials.rb b/actionpack/lib/action_view/render/partials.rb
index 9e5e0f786e..e337dcb63b 100644
--- a/actionpack/lib/action_view/partials.rb
+++ b/actionpack/lib/action_view/render/partials.rb
@@ -172,68 +172,156 @@ module ActionView
   module Partials
     extend ActiveSupport::Memoizable
 
+    def _render_partial(options = {}) #:nodoc:
+      options[:locals] ||= {}
+
+      case path = partial = options[:partial]        
+      when *_array_like_objects
+        return _render_partial_collection(partial, options)
+      else
+        if partial.is_a?(ActionView::Helpers::FormBuilder)
+          path = partial.class.to_s.demodulize.underscore.sub(/_builder$/, '')
+          options[:locals].merge!(path.to_sym => partial)
+        elsif !partial.is_a?(String)
+          options[:object] = object = partial
+          path = ActionController::RecordIdentifier.partial_path(object, controller_path)
+        end
+        _, _, prefix, object = parts = partial_parts(path, options)
+        template = find_by_parts(*parts)
+        _render_partial_object(template, options, (object unless object == true))
+      end
+    end
+
     private
-      def render_partial(options = {}) #:nodoc:
-        local_assigns = options[:locals] || {}
+      def partial_parts(name, options)
+        segments = name.split("/")
+        parts = segments.pop.split(".")
 
-        case partial_path = options[:partial]
-        when String, Symbol, NilClass
-          if options.has_key?(:collection)
-            render_partial_collection(options)
-          else
-            _pick_partial_template(partial_path).render_partial(self, options[:object], local_assigns)
+        case parts.size
+        when 1
+          parts
+        when 2, 3
+          extension = parts.delete_at(1).to_sym
+          if formats.include?(extension)
+            self.formats.replace [extension]
           end
-        when ActionView::Helpers::FormBuilder
-          builder_partial_path = partial_path.class.to_s.demodulize.underscore.sub(/_builder$/, '')
-          local_assigns.merge!(builder_partial_path.to_sym => partial_path)
-          render_partial(:partial => builder_partial_path, :object => options[:object], :locals => local_assigns)
+          parts.pop if parts.size == 2
+        end
+
+        path = parts.join(".")
+        prefix = segments[0..-1].join("/")
+        prefix = prefix.blank? ? controller_path : prefix
+        parts = [path, formats, prefix]
+        parts.push options[:object] || true
+      end
+
+      def _render_partial_with_block(layout, block, options)
+        @_proc_for_layout = block
+        concat(_render_partial(options.merge(:partial => layout)))
+      ensure
+        @_proc_for_layout = nil
+      end
+  
+      def _render_partial_with_layout(layout, options)
+        if layout
+          prefix = controller && !layout.include?("/") ? controller.controller_path : nil
+          layout = find_by_parts(layout, formats, prefix, true)
+        end
+        content = _render_partial(options)
+        return _render_content_with_layout(content, layout, options[:locals])
+      end
+    
+      def _deprecated_ivar_assign(template)
+        if respond_to?(:controller)
+          ivar = :"@#{template.variable_name}"
+          object =
+            if controller.instance_variable_defined?(ivar)
+              ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
+                controller.instance_variable_get(ivar),
+                "#{ivar} will no longer be implicitly assigned to #{template.variable_name}")
+            end
+        end
+      end
+
+      def _render_partial_with_block(layout, block, options)
+        @_proc_for_layout = block
+        concat(_render_partial(options.merge(:partial => layout)))
+      ensure
+        @_proc_for_layout = nil
+      end
+  
+      def _render_partial_with_layout(layout, options)
+        if layout
+          prefix = controller && !layout.include?("/") ? controller.controller_path : nil
+          layout = find_by_parts(layout, formats, prefix, true)
+        end
+        content = _render_partial(options)
+        return _render_content_with_layout(content, layout, options[:locals])
+      end
+    
+      def _deprecated_ivar_assign(template)
+        if respond_to?(:controller)
+          ivar = :"@#{template.variable_name}"
+          object =
+            if controller.instance_variable_defined?(ivar)
+              ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
+                controller.instance_variable_get(ivar),
+                "#{ivar} will no longer be implicitly assigned to #{template.variable_name}")
+            end
+        end
+      end
+
+      def _array_like_objects
+        array_like = [Array]
+        if defined?(ActiveRecord)
+          array_like.push(ActiveRecord::Associations::AssociationCollection, ActiveRecord::NamedScope::Scope)
+        end
+        array_like
+      end
+
+      def _render_partial_object(template, options, object = nil)
+        if options.key?(:collection)
+          _render_partial_collection(options.delete(:collection), options, template)
         else
-          if Array === partial_path ||
-            (defined?(ActiveRecord) &&
-             (ActiveRecord::Associations::AssociationCollection === partial_path ||
-              ActiveRecord::NamedScope::Scope === partial_path))
-            render_partial_collection(options.except(:partial).merge(:collection => partial_path))
-          else
-            object = partial_path
-            render_partial(
-              :partial => ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path),
-              :object => object,
-              :locals => local_assigns
-            )
-          end
+          locals = (options[:locals] ||= {})
+          object ||= locals[:object] || locals[template.variable_name]
+          
+          _set_locals(object, locals, template, options)          
+          _render_template(template, locals)
         end
       end
 
-      def render_partial_collection(options = {}) #:nodoc:
-        return nil if options[:collection].blank?
+      def _set_locals(object, locals, template, options)
+        object ||= _deprecated_ivar_assign(template)
+        locals[:object] = locals[template.variable_name] = object
+        locals[options[:as]] = object if options[:as]
+      end
+
+      def _render_partial_collection(collection, options = {}, passed_template = nil) #:nodoc:
+        return nil if collection.blank?
+        
+        spacer = options[:spacer_template] ? _render_partial(:partial => options[:spacer_template]) : ''
 
-        partial = options[:partial]
-        spacer = options[:spacer_template] ? render(:partial => options[:spacer_template]) : ''
-        local_assigns = options[:locals] ? options[:locals].clone : {}
-        as = options[:as]
+        locals = (options[:locals] ||= {})
+        index, @_partial_path = 0, nil
+        collection.map do |object|
+          template = passed_template || begin
+            _partial_path = 
+              ActionController::RecordIdentifier.partial_path(object, controller_path)
+            template = _pick_partial_template(_partial_path)
+          end
 
-        index = 0
-        options[:collection].map do |object|
-          _partial_path ||= partial ||
-            ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path)
-          template = _pick_partial_template(_partial_path)
-          local_assigns[template.counter_name] = index
-          result = template.render_partial(self, object, local_assigns.dup, as)
+          _set_locals(object, locals, template, options)
+          locals[template.counter_name] = index
+          
           index += 1
-          result
+          _render_template(template, locals)
         end.join(spacer)
       end
 
       def _pick_partial_template(partial_path) #:nodoc:
-        if partial_path.include?('/')
-          path = File.join(File.dirname(partial_path), "_#{File.basename(partial_path)}")
-        elsif controller
-          path = "#{controller.class.controller_path}/_#{partial_path}"
-        else
-          path = "_#{partial_path}"
-        end
-
-        self.view_paths.find_template(path, self.template_format)
+        prefix = controller_path unless partial_path.include?('/')
+        find_by_parts(partial_path, formats, prefix, true)
       end
       memoize :_pick_partial_template
   end
diff --git a/actionpack/lib/action_view/render/rendering.rb b/actionpack/lib/action_view/render/rendering.rb
new file mode 100644
index 0000000000..a9b2acecd5
--- /dev/null
+++ b/actionpack/lib/action_view/render/rendering.rb
@@ -0,0 +1,114 @@
+module ActionView
+  module Rendering
+    # Returns the result of a render that's dictated by the options hash. The primary options are:
+    #
+    # * <tt>:partial</tt> - See ActionView::Partials.
+    # * <tt>:update</tt> - Calls update_page with the block given.
+    # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
+    # * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.
+    # * <tt>:text</tt> - Renders the text passed in out.
+    #
+    # If no options hash is passed or :update specified, the default is to render a partial and use the second parameter
+    # as the locals hash.
+    def render(options = {}, local_assigns = {}, &block) #:nodoc:
+      local_assigns ||= {}
+
+      @exempt_from_layout = true
+
+      case options
+      when Hash
+        options[:locals] ||= {}
+        layout = options[:layout]
+            
+        return _render_partial_with_layout(layout, options) if options.key?(:partial)
+        return _render_partial_with_block(layout, block, options) if block_given?
+    
+        layout = find_by_parts(layout, formats) if layout
+    
+        if file = options[:file]
+          template = find_by_parts(file, formats)
+          _render_template_with_layout(template, layout, :locals => options[:locals])
+        elsif inline = options[:inline]
+          _render_inline(inline, layout, options)
+        elsif text = options[:text]
+          _render_text(text, layout, options)
+        end
+      when :update
+        update_page(&block)
+      when String, NilClass
+        _render_partial(:partial => options, :locals => local_assigns)
+      end
+    end
+    
+    def _render_content_with_layout(content, layout, locals)
+      return content unless layout
+  
+      locals ||= {}
+
+      if controller && layout
+        response.layout = layout.path_without_format_and_extension if controller.respond_to?(:response)
+        logger.info("Rendering template within #{layout.path_without_format_and_extension}") if logger
+      end
+  
+      begin
+        original_content_for_layout = @content_for_layout if defined?(@content_for_layout)
+        @content_for_layout = content
+
+        @cached_content_for_layout = @content_for_layout
+        _render_template(layout, locals)
+      ensure
+        @content_for_layout = original_content_for_layout
+      end
+    end
+
+    def _render_template(template, local_assigns = {})
+      with_template(template) do
+        _evaluate_assigns_and_ivars
+        _set_controller_content_type(template.mime_type) if template.respond_to?(:mime_type)
+
+        template.render(self, local_assigns) do |*names|
+          if !instance_variable_defined?(:"@content_for_#{names.first}") && 
+          instance_variable_defined?(:@_proc_for_layout) && (proc = @_proc_for_layout)
+            capture(*names, &proc)
+          elsif instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
+            instance_variable_get(ivar)
+          end        
+        end
+      end
+    rescue Exception => e
+      raise e if template.is_a?(InlineTemplate) || !template.filename
+      if TemplateError === e
+        e.sub_template_of(template)
+        raise e
+      else
+        raise TemplateError.new(template, assigns, e)
+      end
+    end
+
+    def _render_inline(inline, layout, options)
+      content = _render_template(InlineTemplate.new(options[:inline], options[:type]), options[:locals] || {})
+      layout ? _render_content_with_layout(content, layout, options[:locals]) : content
+    end
+
+    def _render_text(text, layout, options)
+      layout ? _render_content_with_layout(text, layout, options[:locals]) : text
+    end
+
+    def _render_template_with_layout(template, layout = nil, options = {}, partial = false)
+      if controller && logger
+        logger.info("Rendering #{template.path_without_extension}" + 
+          (options[:status] ? " (#{options[:status]})" : ''))
+      end
+  
+      content = if partial
+        object = partial unless partial == true
+        _render_partial_object(template, options, object)
+      else
+        _render_template(template, options[:locals] || {})
+      end
+  
+      return content unless layout && !template.exempt_from_layout?
+      _render_content_with_layout(content, layout, options[:locals] || {})
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_view/renderable_partial.rb b/actionpack/lib/action_view/renderable_partial.rb
deleted file mode 100644
index 3ea836fa25..0000000000
--- a/actionpack/lib/action_view/renderable_partial.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-module ActionView
-  # NOTE: The template that this mixin is being included into is frozen
-  # so you cannot set or modify any instance variables
-  module RenderablePartial #:nodoc:
-    extend ActiveSupport::Memoizable
-
-    def variable_name
-      name.sub(/\A_/, '').to_sym
-    end
-    memoize :variable_name
-
-    def counter_name
-      "#{variable_name}_counter".to_sym
-    end
-    memoize :counter_name
-
-    def render(view, local_assigns = {})
-      if defined? ActionController
-        ActionController::Base.benchmark("Rendered #{path_without_format_and_extension}", Logger::DEBUG, false) do
-          super
-        end
-      else
-        super
-      end
-    end
-
-    def render_partial(view, object = nil, local_assigns = {}, as = nil)
-      object ||= local_assigns[:object] || local_assigns[variable_name]
-
-      if object.nil? && view.respond_to?(:controller)
-        ivar = :"@#{variable_name}"
-        object =
-          if view.controller.instance_variable_defined?(ivar)
-            ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
-              view.controller.instance_variable_get(ivar),
-              "#{ivar} will no longer be implicitly assigned to #{variable_name}")
-          end
-      end
-
-      # Ensure correct object is reassigned to other accessors
-      local_assigns[:object] = local_assigns[variable_name] = object
-      local_assigns[as] = object if as
-
-      render_template(view, local_assigns)
-    end
-  end
-end
diff --git a/actionpack/lib/action_view/template.rb b/actionpack/lib/action_view/template.rb
deleted file mode 100644
index c339c8a554..0000000000
--- a/actionpack/lib/action_view/template.rb
+++ /dev/null
@@ -1,257 +0,0 @@
-module ActionView #:nodoc:
-  class Template
-    class Path
-      attr_reader :path, :paths
-      delegate :hash, :inspect, :to => :path
-
-      def initialize(path)
-        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
-        @path = (path.ends_with?(File::SEPARATOR) ? path.to(-2) : path).freeze
-      end
-
-      def to_s
-        if defined?(RAILS_ROOT)
-          path.to_s.sub(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '')
-        else
-          path.to_s
-        end
-      end
-
-      def to_str
-        path.to_str
-      end
-
-      def ==(path)
-        to_str == path.to_str
-      end
-
-      def eql?(path)
-        to_str == path.to_str
-      end
-
-      # Returns a ActionView::Template object for the given path string. The
-      # input path should be relative to the view path directory,
-      # +hello/index.html.erb+. This method also has a special exception to
-      # match partial file names without a handler extension. So
-      # +hello/index.html+ will match the first template it finds with a
-      # known template extension, +hello/index.html.erb+. Template extensions
-      # should not be confused with format extensions +html+, +js+, +xml+,
-      # etc. A format must be supplied to match a formated file. +hello/index+
-      # will never match +hello/index.html.erb+.
-      def [](path)
-      end
-
-      def load!
-      end
-
-      def self.new_and_loaded(path)
-        returning new(path) do |path|
-          path.load!
-        end
-      end
-
-      private
-        def relative_path_for_template_file(full_file_path)
-          full_file_path.split("#{@path}/").last
-        end
-    end
-
-    class EagerPath < Path
-      def load!
-        return if @loaded
-        
-        @paths = {}
-        templates_in_path do |template|
-          template.load!
-          template.accessible_paths.each do |path|
-            @paths[path] = template
-          end
-        end
-        @paths.freeze
-        @loaded = true
-      end
-
-      def [](path)
-        load! unless @loaded
-        @paths[path]
-      end
-
-      private
-        def templates_in_path
-          (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
-            yield create_template(file) unless File.directory?(file)
-          end
-        end
-
-        def create_template(file)
-          Template.new(relative_path_for_template_file(file), self)
-        end
-    end
-
-    extend TemplateHandlers
-    extend ActiveSupport::Memoizable
-    include Renderable
-
-    # Templates that are exempt from layouts
-    @@exempt_from_layout = Set.new([/\.rjs$/])
-
-    # Don't render layouts for templates with the given extensions.
-    def self.exempt_from_layout(*extensions)
-      regexps = extensions.collect do |extension|
-        extension.is_a?(Regexp) ? extension : /\.#{Regexp.escape(extension.to_s)}$/
-      end
-      @@exempt_from_layout.merge(regexps)
-    end
-
-    attr_accessor :template_path, :filename, :load_path, :base_path
-    attr_accessor :locale, :name, :format, :extension
-    delegate :to_s, :to => :path
-
-    def initialize(template_path, load_path)
-      @template_path = template_path.dup
-      @load_path, @filename = load_path, File.join(load_path, template_path)
-      @base_path, @name, @locale, @format, @extension = split(template_path)
-      @base_path.to_s.gsub!(/\/$/, '') # Push to split method
-
-      # Extend with partial super powers
-      extend RenderablePartial if @name =~ /^_/
-    end
-
-    def accessible_paths
-      paths = []
-
-      if valid_extension?(extension)
-        paths << path
-        paths << path_without_extension
-        if multipart?
-          formats = format.split(".")
-          paths << "#{path_without_format_and_extension}.#{formats.first}"
-          paths << "#{path_without_format_and_extension}.#{formats.second}"
-        end
-      else
-        # template without explicit template handler should only be reachable through its exact path
-        paths << template_path
-      end
-
-      paths
-    end
-
-    def format_and_extension
-      (extensions = [format, extension].compact.join(".")).blank? ? nil : extensions
-    end
-    memoize :format_and_extension
-
-    def multipart?
-      format && format.include?('.')
-    end
-
-    def content_type
-      format.gsub('.', '/')
-    end
-
-    def mime_type
-      Mime::Type.lookup_by_extension(format) if format && defined?(::Mime)
-    end
-    memoize :mime_type
-
-    def path
-      [base_path, [name, locale, format, extension].compact.join('.')].compact.join('/')
-    end
-    memoize :path
-
-    def path_without_extension
-      [base_path, [name, locale, format].compact.join('.')].compact.join('/')
-    end
-    memoize :path_without_extension
-
-    def path_without_format_and_extension
-      [base_path, [name, locale].compact.join('.')].compact.join('/')
-    end
-    memoize :path_without_format_and_extension
-
-    def relative_path
-      path = File.expand_path(filename)
-      path.sub!(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '') if defined?(RAILS_ROOT)
-      path
-    end
-    memoize :relative_path
-
-    def exempt_from_layout?
-      @@exempt_from_layout.any? { |exempted| path =~ exempted }
-    end
-
-    def source
-      File.read(filename)
-    end
-    memoize :source
-
-    def method_segment
-      relative_path.to_s.gsub(/([^a-zA-Z0-9_])/) { $1.ord }
-    end
-    memoize :method_segment
-
-    def render_template(view, local_assigns = {})
-      render(view, local_assigns)
-    rescue Exception => e
-      raise e unless filename
-      if TemplateError === e
-        e.sub_template_of(self)
-        raise e
-      else
-        raise TemplateError.new(self, view.assigns, e)
-      end
-    end
-
-    def load!
-      freeze
-    end
-
-    private
-      def valid_extension?(extension)
-        !Template.registered_template_handler(extension).nil?
-      end
-
-      def valid_locale?(locale)
-        I18n.available_locales.include?(locale.to_sym)
-      end
-
-      # Returns file split into an array
-      #   [base_path, name, locale, format, extension]
-      def split(file)
-        if m = file.to_s.match(/^(.*\/)?([^\.]+)\.(.*)$/)
-          base_path = m[1]
-          name = m[2]
-          extensions = m[3]
-        else
-          return
-        end
-
-        locale = nil
-        format = nil
-        extension = nil
-
-        if m = extensions.split(".")
-          if valid_locale?(m[0]) && m[1] && valid_extension?(m[2]) # All three
-            locale = m[0]
-            format = m[1]
-            extension = m[2]
-          elsif m[0] && m[1] && valid_extension?(m[2]) # Multipart formats
-            format = "#{m[0]}.#{m[1]}"
-            extension = m[2]
-          elsif valid_locale?(m[0]) && valid_extension?(m[1]) # locale and extension
-            locale = m[0]
-            extension = m[1]
-          elsif valid_extension?(m[1]) # format and extension
-            format = m[0]
-            extension = m[1]
-          elsif valid_extension?(m[0]) # Just extension
-            extension = m[0]
-          else # No extension
-            format = m[0]
-          end
-        end
-
-        [base_path, name, locale, format, extension]
-      end
-  end
-end
diff --git a/actionpack/lib/action_view/template_error.rb b/actionpack/lib/action_view/template/error.rb
index 37cb1c7c6c..37cb1c7c6c 100644
--- a/actionpack/lib/action_view/template_error.rb
+++ b/actionpack/lib/action_view/template/error.rb
diff --git a/actionpack/lib/action_view/template_handler.rb b/actionpack/lib/action_view/template/handler.rb
index 672da0ed2b..672da0ed2b 100644
--- a/actionpack/lib/action_view/template_handler.rb
+++ b/actionpack/lib/action_view/template/handler.rb
diff --git a/actionpack/lib/action_view/template_handlers.rb b/actionpack/lib/action_view/template/handlers.rb
index 205f8628f0..fb85f28851 100644
--- a/actionpack/lib/action_view/template_handlers.rb
+++ b/actionpack/lib/action_view/template/handlers.rb
@@ -1,8 +1,8 @@
 module ActionView #:nodoc:
   module TemplateHandlers #:nodoc:
-    autoload :ERB, 'action_view/template_handlers/erb'
-    autoload :RJS, 'action_view/template_handlers/rjs'
-    autoload :Builder, 'action_view/template_handlers/builder'
+    autoload :ERB, 'action_view/template/handlers/erb'
+    autoload :RJS, 'action_view/template/handlers/rjs'
+    autoload :Builder, 'action_view/template/handlers/builder'
 
     def self.extended(base)
       base.register_default_template_handler :erb, TemplateHandlers::ERB
diff --git a/actionpack/lib/action_view/template_handlers/builder.rb b/actionpack/lib/action_view/template/handlers/builder.rb
index 788dc93326..788dc93326 100644
--- a/actionpack/lib/action_view/template_handlers/builder.rb
+++ b/actionpack/lib/action_view/template/handlers/builder.rb
diff --git a/actionpack/lib/action_view/template_handlers/erb.rb b/actionpack/lib/action_view/template/handlers/erb.rb
index e3120ba267..a20b1b0cd3 100644
--- a/actionpack/lib/action_view/template_handlers/erb.rb
+++ b/actionpack/lib/action_view/template/handlers/erb.rb
@@ -1,3 +1,5 @@
+require 'erb'
+
 module ActionView
   module TemplateHandlers
     class ERB < TemplateHandler
diff --git a/actionpack/lib/action_view/template_handlers/rjs.rb b/actionpack/lib/action_view/template/handlers/rjs.rb
index 41a1fddb47..802a79b3fc 100644
--- a/actionpack/lib/action_view/template_handlers/rjs.rb
+++ b/actionpack/lib/action_view/template/handlers/rjs.rb
@@ -4,7 +4,7 @@ module ActionView
       include Compilable
 
       def compile(template)
-        "@template_format = :html;" +
+        "@formats = [:html];" +
         "controller.response.content_type ||= Mime::JS;" +
           "update_page do |page|;#{template.source}\nend"
       end
diff --git a/actionpack/lib/action_view/inline_template.rb b/actionpack/lib/action_view/template/inline.rb
index 54efa543c8..54efa543c8 100644
--- a/actionpack/lib/action_view/inline_template.rb
+++ b/actionpack/lib/action_view/template/inline.rb
diff --git a/actionpack/lib/action_view/template/partial.rb b/actionpack/lib/action_view/template/partial.rb
new file mode 100644
index 0000000000..30dec1dc5b
--- /dev/null
+++ b/actionpack/lib/action_view/template/partial.rb
@@ -0,0 +1,18 @@
+module ActionView
+  # NOTE: The template that this mixin is being included into is frozen
+  # so you cannot set or modify any instance variables
+  module RenderablePartial #:nodoc:
+    extend ActiveSupport::Memoizable
+
+    def variable_name
+      name.sub(/\A_/, '').to_sym
+    end
+    memoize :variable_name
+
+    def counter_name
+      "#{variable_name}_counter".to_sym
+    end
+    memoize :counter_name
+
+  end
+end
diff --git a/actionpack/lib/action_view/template/path.rb b/actionpack/lib/action_view/template/path.rb
new file mode 100644
index 0000000000..9709549b70
--- /dev/null
+++ b/actionpack/lib/action_view/template/path.rb
@@ -0,0 +1,87 @@
+module ActionView
+  class Template
+    class Path
+      attr_reader :path, :paths
+      delegate :hash, :inspect, :to => :path
+      
+      def initialize(options)
+        @cache = options[:cache]
+      end
+
+      def to_s
+        if defined?(RAILS_ROOT)
+          path.to_s.sub(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '')
+        else
+          path.to_s
+        end
+      end
+
+      def to_str
+        path.to_str
+      end
+
+      def ==(path)
+        to_str == path.to_str
+      end
+
+      def eql?(path)
+        to_str == path.to_str
+      end
+
+      def find_by_parts(name, extensions = nil, prefix = nil, partial = nil)
+        path = prefix ? "#{prefix}/" : ""
+    
+        name = name.to_s.split("/")
+        name[-1] = "_#{name[-1]}" if partial
+    
+        path << name.join("/")
+
+        template = nil
+
+        Array(extensions).each do |extension|
+          extensioned_path = extension ? "#{path}.#{extension}" : path
+          break if (template = find_template(extensioned_path))
+        end
+        template || find_template(path)
+      end
+  
+    private
+      def create_template(file)
+        Template.new(file.split("#{self}/").last, self)
+      end
+    end
+
+    class FileSystemPath < Path
+      def initialize(path, options = {})
+        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)        
+        
+        super(options)
+        @path, @paths = path, {}
+        
+        # **/*/** is a hax for symlinked directories
+        load_templates("#{@path}/{**/*,**}/**") if @cache
+      end
+
+    private
+    
+      def load_template(template)
+        template.load!
+        template.accessible_paths.each do |path|
+          @paths[path] = template
+        end
+      end
+    
+      def find_template(path)
+        load_templates("#{@path}/#{path}{,.*}") unless @cache
+        @paths[path]
+      end    
+    
+      def load_templates(glob)
+        Dir[glob].each do |file|
+          load_template(create_template(file)) unless File.directory?(file)
+        end
+      end
+      
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_view/renderable.rb b/actionpack/lib/action_view/template/renderable.rb
index ff7bc7d9de..54857516ab 100644
--- a/actionpack/lib/action_view/renderable.rb
+++ b/actionpack/lib/action_view/template/renderable.rb
@@ -6,6 +6,23 @@ module ActionView
   module Renderable #:nodoc:
     extend ActiveSupport::Memoizable
 
+    def render(view, locals)
+      compile(locals)
+      view.send(method_name(locals), locals) {|*args| yield(*args) }
+    end
+    
+    def load!
+      names = Base::CompiledTemplates.instance_methods.grep(/#{method_name_without_locals}/)
+      names.each do |name|
+        Base::CompiledTemplates.class_eval do
+          remove_method(name)
+        end
+      end
+      super
+    end
+    
+  private
+  
     def filename
       'compiled-template'
     end
@@ -18,30 +35,13 @@ module ActionView
     def compiled_source
       handler.call(self)
     end
+    memoize :compiled_source
 
     def method_name_without_locals
       ['_run', extension, method_segment].compact.join('_')
     end
     memoize :method_name_without_locals
 
-    def render(view, local_assigns = {})
-      compile(local_assigns)
-
-      view.with_template self do
-        view.send(:_evaluate_assigns_and_ivars)
-        view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
-
-        view.send(method_name(local_assigns), local_assigns) do |*names|
-          ivar = :@_proc_for_layout
-          if !view.instance_variable_defined?(:"@content_for_#{names.first}") && view.instance_variable_defined?(ivar) && (proc = view.instance_variable_get(ivar))
-            view.capture(*names, &proc)
-          elsif view.instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
-            view.instance_variable_get(ivar)
-          end
-        end
-      end
-    end
-
     def method_name(local_assigns)
       if local_assigns && local_assigns.any?
         method_name = method_name_without_locals.dup
@@ -52,16 +52,16 @@ module ActionView
       method_name.to_sym
     end
 
-    private
-      # Compile and evaluate the template's code (if necessary)
-      def compile(local_assigns)
-        render_symbol = method_name(local_assigns)
+    # Compile and evaluate the template's code (if necessary)
+    def compile(local_assigns)
+      render_symbol = method_name(local_assigns)
 
-        if !Base::CompiledTemplates.method_defined?(render_symbol) || recompile?
-          compile!(render_symbol, local_assigns)
-        end
+      if !Base::CompiledTemplates.method_defined?(render_symbol) || recompile?
+        compile!(render_symbol, local_assigns)
       end
+    end
 
+    private
       def compile!(render_symbol, local_assigns)
         locals_code = local_assigns.keys.map { |key| "#{key} = local_assigns[:#{key}];" }.join
 
@@ -74,9 +74,7 @@ module ActionView
         end_src
 
         begin
-          ActionView::Base::CompiledTemplates.module_eval(source, filename, 0)
-        rescue Errno::ENOENT => e
-          raise e # Missing template file, re-raise for Base to rescue
+          ActionView::Base::CompiledTemplates.module_eval(source, filename.to_s, 0)
         rescue Exception => e # errors from template code
           if logger = defined?(ActionController) && Base.logger
             logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
diff --git a/actionpack/lib/action_view/template/template.rb b/actionpack/lib/action_view/template/template.rb
new file mode 100644
index 0000000000..0d2f201458
--- /dev/null
+++ b/actionpack/lib/action_view/template/template.rb
@@ -0,0 +1,187 @@
+require "action_view/template/path"
+
+module ActionView #:nodoc:
+  class Template
+    extend TemplateHandlers
+    extend ActiveSupport::Memoizable
+    
+    module Loading
+      def load!
+        @cached = true
+        # freeze
+      end    
+    end
+    include Loading    
+    
+    include Renderable
+
+    # Templates that are exempt from layouts
+    @@exempt_from_layout = Set.new([/\.rjs$/])
+
+    # Don't render layouts for templates with the given extensions.
+    def self.exempt_from_layout(*extensions)
+      regexps = extensions.collect do |extension|
+        extension.is_a?(Regexp) ? extension : /\.#{Regexp.escape(extension.to_s)}$/
+      end
+      @@exempt_from_layout.merge(regexps)
+    end
+
+    attr_accessor :template_path, :filename, :load_path, :base_path
+    attr_accessor :locale, :name, :format, :extension
+    delegate :to_s, :to => :path
+
+    def initialize(template_path, load_paths = [])
+      template_path = template_path.dup
+      @load_path, @filename = find_full_path(template_path, load_paths)
+      @base_path, @name, @locale, @format, @extension = split(template_path)
+      @base_path.to_s.gsub!(/\/$/, '') # Push to split method
+
+      # Extend with partial super powers
+      extend RenderablePartial if @name =~ /^_/
+    end
+    
+    def accessible_paths
+      paths = []
+
+      if valid_extension?(extension)
+        paths << path
+        paths << path_without_extension
+        if multipart?
+          formats = format.split(".")
+          paths << "#{path_without_format_and_extension}.#{formats.first}"
+          paths << "#{path_without_format_and_extension}.#{formats.second}"
+        end
+      else
+        # template without explicit template handler should only be reachable through its exact path
+        paths << template_path
+      end
+
+      paths
+    end
+    
+    def relative_path
+      path = File.expand_path(filename)
+      path.sub!(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '') if defined?(RAILS_ROOT)
+      path
+    end
+    memoize :relative_path
+    
+    def source
+      File.read(filename)
+    end
+    memoize :source
+    
+    def exempt_from_layout?
+      @@exempt_from_layout.any? { |exempted| path =~ exempted }
+    end    
+    
+    def path_without_extension
+      [base_path, [name, locale, format].compact.join('.')].compact.join('/')
+    end
+    memoize :path_without_extension    
+
+    def path_without_format_and_extension
+      [base_path, [name, locale].compact.join('.')].compact.join('/')
+    end
+    memoize :path_without_format_and_extension
+    
+    def path
+      [base_path, [name, locale, format, extension].compact.join('.')].compact.join('/')
+    end
+    memoize :path
+    
+    def mime_type
+      Mime::Type.lookup_by_extension(format) if format && defined?(::Mime)
+    end
+    memoize :mime_type      
+    
+    def multipart?
+      format && format.include?('.')
+    end    
+    
+    def content_type
+      format.gsub('.', '/')
+    end    
+    
+  private
+    
+    def format_and_extension
+      (extensions = [format, extension].compact.join(".")).blank? ? nil : extensions
+    end
+    memoize :format_and_extension
+
+    def mtime
+      File.mtime(filename)
+    end
+    memoize :mtime
+
+    def method_segment
+      relative_path.to_s.gsub(/([^a-zA-Z0-9_])/) { $1.ord }
+    end
+    memoize :method_segment
+
+    def stale?
+      File.mtime(filename) > mtime
+    end
+
+    def recompile?
+      !@cached
+    end
+
+    def valid_extension?(extension)
+      !Template.registered_template_handler(extension).nil?
+    end
+
+    def valid_locale?(locale)
+      I18n.available_locales.include?(locale.to_sym)
+    end
+
+    def find_full_path(path, load_paths)
+      load_paths = Array(load_paths) + [nil]
+      load_paths.each do |load_path|
+        file = load_path ? "#{load_path.to_str}/#{path}" : path
+        return load_path, file if File.file?(file)
+      end
+      raise MissingTemplate.new(load_paths, path)
+    end
+
+    # Returns file split into an array
+    #   [base_path, name, locale, format, extension]
+    def split(file)
+      if m = file.to_s.match(/^(.*\/)?([^\.]+)\.(.*)$/)
+        base_path = m[1]
+        name = m[2]
+        extensions = m[3]
+      else
+        return
+      end
+
+      locale = nil
+      format = nil
+      extension = nil
+
+      if m = extensions.split(".")
+        if valid_locale?(m[0]) && m[1] && valid_extension?(m[2]) # All three
+          locale = m[0]
+          format = m[1]
+          extension = m[2]
+        elsif m[0] && m[1] && valid_extension?(m[2]) # Multipart formats
+          format = "#{m[0]}.#{m[1]}"
+          extension = m[2]
+        elsif valid_locale?(m[0]) && valid_extension?(m[1]) # locale and extension
+          locale = m[0]
+          extension = m[1]
+        elsif valid_extension?(m[1]) # format and extension
+          format = m[0]
+          extension = m[1]
+        elsif valid_extension?(m[0]) # Just extension
+          extension = m[0]
+        else # No extension
+          format = m[0]
+        end
+      end
+
+      [base_path, name, locale, format, extension]
+    end
+  end
+end
diff --git a/actionpack/lib/action_view/template/text.rb b/actionpack/lib/action_view/template/text.rb
new file mode 100644
index 0000000000..f81174d707
--- /dev/null
+++ b/actionpack/lib/action_view/template/text.rb
@@ -0,0 +1,9 @@
+module ActionView #:nodoc:
+  class TextTemplate < String #:nodoc:
+    
+    def render(*) self end
+    
+    def exempt_from_layout?() false end
+    
+  end
+end
diff --git a/actionpack/lib/action_view/test_case.rb b/actionpack/lib/action_view/test_case.rb
index ec337bb05b..c8f204046b 100644
--- a/actionpack/lib/action_view/test_case.rb
+++ b/actionpack/lib/action_view/test_case.rb
@@ -7,18 +7,15 @@ module ActionView
       @_rendered = { :template => nil, :partials => Hash.new(0) }
       initialize_without_template_tracking(*args)
     end
-  end
-
-  module Renderable
-    alias_method :render_without_template_tracking, :render
-    def render(view, local_assigns = {})
-      if respond_to?(:path) && !is_a?(InlineTemplate)
-        rendered = view.instance_variable_get(:@_rendered)
-        rendered[:partials][self] += 1 if is_a?(RenderablePartial)
-        rendered[:template] ||= self
+    
+    alias_method :_render_template_without_template_tracking, :_render_template
+    def _render_template(template, local_assigns = {})
+      if template.respond_to?(:path) && !template.is_a?(InlineTemplate)
+        @_rendered[:partials][template] += 1 if template.is_a?(RenderablePartial)
+        @_rendered[:template] ||= template
       end
-      render_without_template_tracking(view, local_assigns)
-    end
+      _render_template_without_template_tracking(template, local_assigns)
+    end    
   end
 
   class TestCase < ActiveSupport::TestCase
diff --git a/actionpack/test/abstract_controller/abstract_controller_test.rb b/actionpack/test/abstract_controller/abstract_controller_test.rb
new file mode 100644
index 0000000000..918062c7db
--- /dev/null
+++ b/actionpack/test/abstract_controller/abstract_controller_test.rb
@@ -0,0 +1,244 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module AbstractController
+  module Testing
+  
+    # Test basic dispatching.
+    # ====
+    # * Call process
+    # * Test that the response_body is set correctly
+    class SimpleController < AbstractController::Base
+    end
+    
+    class Me < SimpleController
+      def index
+        self.response_body = "Hello world"
+        "Something else"
+      end      
+    end
+    
+    class TestBasic < ActiveSupport::TestCase
+      test "dispatching works" do
+        result = Me.process(:index)
+        assert_equal "Hello world", result.response_obj[:body]
+      end
+    end
+    
+    # Test Render mixin
+    # ====
+    class RenderingController < AbstractController::Base
+      use Renderer
+
+      def _prefix() end
+
+      def render(options = {})
+        if options.is_a?(String)
+          options = {:_template_name => options}
+        end
+        
+        options[:_prefix] = _prefix
+        super
+      end
+
+      append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views"))
+    end
+    
+    class Me2 < RenderingController
+      def index
+        render "index.erb"
+      end
+      
+      def action_with_ivars
+        @my_ivar = "Hello"
+        render "action_with_ivars.erb"
+      end
+      
+      def naked_render
+        render
+      end
+
+      def rendering_to_body
+        render_to_body "naked_render.erb"
+      end
+
+      def rendering_to_string
+        render_to_string "naked_render.erb"
+      end
+    end
+    
+    class TestRenderer < ActiveSupport::TestCase
+      test "rendering templates works" do
+        result = Me2.process(:index)
+        assert_equal "Hello from index.erb", result.response_obj[:body]
+      end
+      
+      test "rendering passes ivars to the view" do
+        result = Me2.process(:action_with_ivars)
+        assert_equal "Hello from index_with_ivars.erb", result.response_obj[:body]
+      end
+      
+      test "rendering with no template name" do
+        result = Me2.process(:naked_render)
+        assert_equal "Hello from naked_render.erb", result.response_obj[:body]
+      end
+
+      test "rendering to a rack body" do
+        result = Me2.process(:rendering_to_body)
+        assert_equal "Hello from naked_render.erb", result.response_obj[:body]
+      end
+
+      test "rendering to a string" do
+        result = Me2.process(:rendering_to_string)
+        assert_equal "Hello from naked_render.erb", result.response_obj[:body]
+      end
+    end
+    
+    # Test rendering with prefixes
+    # ====
+    # * self._prefix is used when defined
+    class PrefixedViews < RenderingController
+      private
+      def self.prefix
+        name.underscore
+      end
+      
+      def _prefix
+        self.class.prefix
+      end
+    end
+    
+    class Me3 < PrefixedViews
+      def index
+        render
+      end
+      
+      def formatted
+        self.formats = [:html]
+        render
+      end
+    end
+    
+    class TestPrefixedViews < ActiveSupport::TestCase
+      test "templates are located inside their 'prefix' folder" do
+        result = Me3.process(:index)
+        assert_equal "Hello from me3/index.erb", result.response_obj[:body]
+      end
+
+      test "templates included their format" do
+        result = Me3.process(:formatted)
+        assert_equal "Hello from me3/formatted.html.erb", result.response_obj[:body]
+      end
+    end
+    
+    # Test rendering with layouts
+    # ====
+    # self._layout is used when defined
+    class WithLayouts < PrefixedViews
+      use Layouts
+      
+      private
+      def self.layout(formats)
+        begin
+          view_paths.find_by_parts(name.underscore, formats, "layouts")
+        rescue ActionView::MissingTemplate
+          begin
+            view_paths.find_by_parts("application", formats, "layouts")
+          rescue ActionView::MissingTemplate
+          end
+        end
+      end
+      
+      def _layout
+        self.class.layout(formats)
+      end      
+      
+      def render_to_body(options = {})
+        options[:_layout] = options[:layout] || _layout
+        super
+      end  
+    end
+    
+    class Me4 < WithLayouts
+      def index
+        render
+      end
+    end
+    
+    class Me5 < WithLayouts
+      def index
+        render
+      end
+    end
+    
+    class TestLayouts < ActiveSupport::TestCase
+      test "layouts are included" do
+        result = Me4.process(:index)
+        assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", result.response_obj[:body]
+      end
+      
+      test "it can fall back to the application layout" do
+        result = Me5.process(:index)
+        assert_equal "Application Enter : Hello from me5/index.erb : Exit", result.response_obj[:body]        
+      end
+    end
+    
+    # respond_to_action?(action_name)
+    # ====
+    # * A method can be used as an action only if this method
+    #   returns true when passed the method name as an argument
+    # * Defaults to true in AbstractController
+    class DefaultRespondToActionController < AbstractController::Base
+      def index() self.response_body = "success" end
+    end
+    
+    class ActionMissingRespondToActionController < AbstractController::Base
+      # No actions
+    private
+      def action_missing(action_name)
+        self.response_body = "success"
+      end
+    end
+    
+    class RespondToActionController < AbstractController::Base;
+      def index() self.response_body = "success" end
+        
+      def fail()  self.response_body = "fail"    end
+        
+    private
+      
+      def respond_to_action?(action_name)
+        action_name != :fail
+      end
+      
+    end
+    
+    class TestRespondToAction < ActiveSupport::TestCase
+      
+      def assert_dispatch(klass, body = "success", action = :index)
+        response = klass.process(action).response_obj[:body]
+        assert_equal body, response
+      end
+      
+      test "an arbitrary method is available as an action by default" do
+        assert_dispatch DefaultRespondToActionController, "success", :index
+      end
+      
+      test "raises ActionNotFound when method does not exist and action_missing is not defined" do
+        assert_raise(ActionNotFound) { DefaultRespondToActionController.process(:fail) }
+      end
+      
+      test "dispatches to action_missing when method does not exist and action_missing is defined" do
+        assert_dispatch ActionMissingRespondToActionController, "success", :ohai
+      end
+      
+      test "a method is available as an action if respond_to_action? returns true" do
+        assert_dispatch RespondToActionController, "success", :index
+      end
+      
+      test "raises ActionNotFound if method is defined but respond_to_action? returns false" do
+        assert_raise(ActionNotFound) { RespondToActionController.process(:fail) }
+      end
+    end
+    
+  end
+end
diff --git a/actionpack/test/abstract_controller/callbacks_test.rb b/actionpack/test/abstract_controller/callbacks_test.rb
new file mode 100644
index 0000000000..5fce30f478
--- /dev/null
+++ b/actionpack/test/abstract_controller/callbacks_test.rb
@@ -0,0 +1,197 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module AbstractController
+  module Testing
+  
+    class ControllerWithCallbacks < AbstractController::Base
+      use AbstractController::Callbacks
+    end
+    
+    class Callback1 < ControllerWithCallbacks
+      process_action_callback :before, :first
+      
+      def first
+        @text = "Hello world"
+      end
+      
+      def index
+        self.response_body = @text
+      end
+    end
+    
+    class TestCallbacks < ActiveSupport::TestCase
+      test "basic callbacks work" do
+        result = Callback1.process(:index)
+        assert_equal "Hello world", result.response_obj[:body]
+      end
+    end
+
+    class Callback2 < ControllerWithCallbacks
+      before_filter :first
+      after_filter :second
+      around_filter :aroundz
+      
+      def first
+        @text = "Hello world"
+      end
+      
+      def second
+        @second = "Goodbye"
+      end
+      
+      def aroundz
+        @aroundz = "FIRST"
+        yield
+        @aroundz << "SECOND"
+      end
+      
+      def index
+        self.response_body = @text
+      end      
+    end
+    
+    class TestCallbacks < ActiveSupport::TestCase
+      test "before_filter works" do
+        result = Callback2.process(:index)
+        assert_equal "Hello world", result.response_obj[:body]
+      end
+      
+      test "after_filter works" do
+        result = Callback2.process(:index)
+        assert_equal "Goodbye", result.instance_variable_get("@second")
+      end
+      
+      test "around_filter works" do
+        result = Callback2.process(:index)
+        assert_equal "FIRSTSECOND", result.instance_variable_get("@aroundz")
+      end
+    end
+    
+    class Callback3 < ControllerWithCallbacks
+      before_filter do |c|
+        c.instance_variable_set("@text", "Hello world")
+      end
+      
+      after_filter do |c|
+        c.instance_variable_set("@second", "Goodbye")
+      end
+            
+      def index
+        self.response_body = @text
+      end
+    end
+
+    class TestCallbacks < ActiveSupport::TestCase
+      test "before_filter works with procs" do
+        result = Callback3.process(:index)
+        assert_equal "Hello world", result.response_obj[:body]
+      end
+      
+      test "after_filter works with procs" do
+        result = Callback3.process(:index)
+        assert_equal "Goodbye", result.instance_variable_get("@second")
+      end      
+    end
+    
+    class CallbacksWithConditions < ControllerWithCallbacks
+      before_filter :list, :only => :index
+      before_filter :authenticate, :except => :index
+      
+      def index
+        self.response_body = @list.join(", ")
+      end
+      
+      def sekrit_data
+        self.response_body = (@list + [@authenticated]).join(", ")
+      end
+      
+      private
+      def list
+        @list = ["Hello", "World"]
+      end
+      
+      def authenticate
+        @list = []
+        @authenticated = "true"
+      end
+    end
+    
+    class TestCallbacks < ActiveSupport::TestCase
+      test "when :only is specified, a before filter is triggered on that action" do
+        result = CallbacksWithConditions.process(:index)
+        assert_equal "Hello, World", result.response_obj[:body]
+      end
+      
+      test "when :only is specified, a before filter is not triggered on other actions" do
+        result = CallbacksWithConditions.process(:sekrit_data)
+        assert_equal "true", result.response_obj[:body]
+      end
+      
+      test "when :except is specified, an after filter is not triggered on that action" do
+        result = CallbacksWithConditions.process(:index)
+        assert_nil result.instance_variable_get("@authenticated")
+      end
+    end
+    
+    class CallbacksWithArrayConditions < ControllerWithCallbacks
+      before_filter :list, :only => [:index, :listy]
+      before_filter :authenticate, :except => [:index, :listy]
+      
+      def index
+        self.response_body = @list.join(", ")
+      end
+      
+      def sekrit_data
+        self.response_body = (@list + [@authenticated]).join(", ")
+      end
+      
+      private
+      def list
+        @list = ["Hello", "World"]
+      end
+      
+      def authenticate
+        @list = []
+        @authenticated = "true"
+      end      
+    end
+    
+    class TestCallbacks < ActiveSupport::TestCase
+      test "when :only is specified with an array, a before filter is triggered on that action" do
+        result = CallbacksWithArrayConditions.process(:index)
+        assert_equal "Hello, World", result.response_obj[:body]
+      end
+      
+      test "when :only is specified with an array, a before filter is not triggered on other actions" do
+        result = CallbacksWithArrayConditions.process(:sekrit_data)
+        assert_equal "true", result.response_obj[:body]
+      end
+      
+      test "when :except is specified with an array, an after filter is not triggered on that action" do
+        result = CallbacksWithArrayConditions.process(:index)
+        assert_nil result.instance_variable_get("@authenticated")
+      end
+    end    
+    
+    class ChangedConditions < Callback2
+      before_filter :first, :only => :index
+      
+      def not_index
+        self.response_body = @text.to_s
+      end
+    end
+    
+    class TestCallbacks < ActiveSupport::TestCase
+      test "when a callback is modified in a child with :only, it works for the :only action" do
+        result = ChangedConditions.process(:index)
+        assert_equal "Hello world", result.response_obj[:body]
+      end
+      
+      test "when a callback is modified in a child with :only, it does not work for other actions" do
+        result = ChangedConditions.process(:not_index)
+        assert_equal "", result.response_obj[:body]        
+      end
+    end
+    
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/helper_test.rb b/actionpack/test/abstract_controller/helper_test.rb
new file mode 100644
index 0000000000..6284fa4f70
--- /dev/null
+++ b/actionpack/test/abstract_controller/helper_test.rb
@@ -0,0 +1,43 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module AbstractController
+  module Testing
+  
+    class ControllerWithHelpers < AbstractController::Base
+      use Renderer
+      use Helpers
+      
+      def render(string)
+        super(:_template_name => string)
+      end
+      
+      append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views"))
+    end
+   
+    module HelperyTest
+      def included_method
+        "Included"
+      end
+    end
+   
+    class MyHelpers1 < ControllerWithHelpers
+      helper(HelperyTest) do
+        def helpery_test
+          "World"
+        end
+      end
+      
+      def index
+        render "helper_test.erb"
+      end
+    end
+    
+    class TestHelpers < ActiveSupport::TestCase
+      def test_helpers
+        result = MyHelpers1.process(:index)
+        assert_equal "Hello World : Included", result.response_obj[:body]
+      end
+    end
+    
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/layouts_test.rb b/actionpack/test/abstract_controller/layouts_test.rb
new file mode 100644
index 0000000000..3d4570bfef
--- /dev/null
+++ b/actionpack/test/abstract_controller/layouts_test.rb
@@ -0,0 +1,232 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module AbstractControllerTests
+  module Layouts
+
+    # Base controller for these tests
+    class Base < AbstractController::Base
+      use AbstractController::Renderer
+      use AbstractController::Layouts
+      
+      self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+        "layouts/hello.erb"                     => "With String <%= yield %>",
+        "layouts/hello_override.erb"            => "With Override <%= yield %>",
+        "layouts/abstract_controller_tests/layouts/with_string_implied_child.erb" =>
+                                                   "With Implied <%= yield %>",
+        "layouts/omg.erb"                       => "OMGHI2U <%= yield %>",
+        "layouts/with_false_layout.erb"         => "False Layout <%= yield %>"
+      )]
+
+      def self.controller_path
+        @controller_path ||= self.name.sub(/Controller$/, '').underscore
+      end
+      
+      def controller_path() self.class.controller_path end
+      
+      def render_to_body(options)
+        options[:_layout] = _default_layout
+        super
+      end
+    end
+    
+    class Blank < Base
+      self.view_paths = []
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello blank!")
+      end
+    end
+    
+    class WithString < Base
+      layout "hello"
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello string!")
+      end
+    end
+    
+    class WithStringChild < WithString
+    end
+    
+    class WithStringOverriddenChild < WithString
+      layout "hello_override"
+    end
+    
+    class WithNilChild < WithString
+      layout nil
+    end    
+    
+    class WithStringImpliedChild < WithString
+    end
+    
+    class WithChildOfImplied < WithStringImpliedChild
+    end
+    
+    class WithSymbol < Base
+      layout :hello
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello symbol!")
+      end
+    private  
+      def hello
+        "omg"
+      end
+    end
+    
+    class WithSymbolReturningString < Base
+      layout :no_hello
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello missing symbol!")
+      end
+    private  
+      def no_hello
+        nil
+      end
+    end
+    
+    class WithSymbolReturningNil < Base
+      layout :nilz
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello nilz!")
+      end
+      
+      def nilz() end
+    end
+    
+    class WithSymbolReturningObj < Base
+      layout :objekt
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello nilz!")
+      end
+      
+      def objekt
+        Object.new
+      end
+    end    
+    
+    class WithSymbolAndNoMethod < Base
+      layout :omg_no_method
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello boom!")
+      end
+    end
+    
+    class WithMissingLayout < Base
+      layout "missing"
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello missing!")
+      end
+    end
+    
+    class WithFalseLayout < Base
+      layout false
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello false!")
+      end
+    end
+    
+    class WithNilLayout < Base
+      layout nil
+      
+      def index
+        render :_template => ActionView::TextTemplate.new("Hello nil!")
+      end
+    end
+    
+    # TODO Move to bootloader
+    AbstractController::Base.subclasses.each do |klass|
+      klass = klass.constantize
+      next unless klass < AbstractController::Layouts
+      klass.class_eval do
+        _write_layout_method
+      end
+    end
+    
+    class TestBase < ActiveSupport::TestCase
+      test "when no layout is specified, and no default is available, render without a layout" do
+        result = Blank.process(:index)
+        assert_equal "Hello blank!", result.response_obj[:body]
+      end
+      
+      test "when layout is specified as a string, render with that layout" do
+        result = WithString.process(:index)
+        assert_equal "With String Hello string!", result.response_obj[:body]
+      end
+      
+      test "when layout is specified as a string, but the layout is missing, raise an exception" do
+        assert_raises(ActionView::MissingTemplate) { WithMissingLayout.process(:index) }
+      end
+      
+      test "when layout is specified as false, do not use a layout" do
+        result = WithFalseLayout.process(:index)
+        assert_equal "Hello false!", result.response_obj[:body]
+      end
+      
+      test "when layout is specified as nil, do not use a layout" do
+        result = WithNilLayout.process(:index)
+        assert_equal "Hello nil!", result.response_obj[:body]
+      end
+      
+      test "when layout is specified as a symbol, call the requested method and use the layout returned" do
+        result = WithSymbol.process(:index)
+        assert_equal "OMGHI2U Hello symbol!", result.response_obj[:body]
+      end
+      
+      test "when layout is specified as a symbol and the method returns nil, don't use a layout" do
+        result = WithSymbolReturningNil.process(:index)
+        assert_equal "Hello nilz!", result.response_obj[:body]
+      end
+      
+      test "when the layout is specified as a symbol and the method doesn't exist, raise an exception" do
+        assert_raises(NoMethodError, /:nilz/) { WithSymbolAndNoMethod.process(:index) }
+      end
+      
+      test "when the layout is specified as a symbol and the method returns something besides a string/false/nil, raise an exception" do
+        assert_raises(ArgumentError) { WithSymbolReturningObj.process(:index) }
+      end
+      
+      test "when a child controller does not have a layout, use the parent controller layout" do
+        result = WithStringChild.process(:index)
+        assert_equal "With String Hello string!", result.response_obj[:body]
+      end
+      
+      test "when a child controller has specified a layout, use that layout and not the parent controller layout" do
+        result = WithStringOverriddenChild.process(:index)
+        assert_equal "With Override Hello string!", result.response_obj[:body]
+      end
+      
+      test "when a child controller has an implied layout, use that layout and not the parent controller layout" do
+        result = WithStringImpliedChild.process(:index)
+        assert_equal "With Implied Hello string!", result.response_obj[:body]
+      end
+      
+      test "when a child controller specifies layout nil, do not use the parent layout" do
+        result = WithNilChild.process(:index)
+        assert_equal "Hello string!", result.response_obj[:body]
+      end
+            
+      test "when a grandchild has no layout specified, the child has an implied layout, and the " \
+        "parent has specified a layout, use the child controller layout" do
+          result = WithChildOfImplied.process(:index)
+          assert_equal "With Implied Hello string!", result.response_obj[:body]
+      end
+      
+      test "raises an exception when specifying layout true" do
+        assert_raises ArgumentError do
+          Object.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+            class ::BadOmgFailLolLayout < AbstractControllerTests::Layouts::Base
+              layout true
+            end
+          RUBY_EVAL
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/test/abstract_controller/test_helper.rb b/actionpack/test/abstract_controller/test_helper.rb
new file mode 100644
index 0000000000..b9248c6bbd
--- /dev/null
+++ b/actionpack/test/abstract_controller/test_helper.rb
@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'action_controller'
+require 'action_view/base'
+require 'fixture_template'
+
+begin
+  require 'ruby-debug'
+  Debugger.settings[:autoeval] = true
+  Debugger.start
+rescue LoadError
+  # Debugging disabled. `gem install ruby-debug` to enable.
+end
+
+require 'action_controller/abstract'
+# require 'action_controller/abstract/base'
+# require 'action_controller/abstract/renderer'
+# require 'action_controller/abstract/layouts'
+# require 'action_controller/abstract/callbacks'
+# require 'action_controller/abstract/helpers'
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/formatted.html.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/formatted.html.erb
new file mode 100644
index 0000000000..785bf69191
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/formatted.html.erb
@@ -0,0 +1 @@
+Hello from me3/formatted.html.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/index.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/index.erb
new file mode 100644
index 0000000000..f079ad8204
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/index.erb
@@ -0,0 +1 @@
+Hello from me3/index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me4/index.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me4/index.erb
new file mode 100644
index 0000000000..89dce12bdc
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me4/index.erb
@@ -0,0 +1 @@
+Hello from me4/index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me5/index.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me5/index.erb
new file mode 100644
index 0000000000..84d0b7417e
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me5/index.erb
@@ -0,0 +1 @@
+Hello from me5/index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/action_with_ivars.erb b/actionpack/test/abstract_controller/views/action_with_ivars.erb
new file mode 100644
index 0000000000..8d8ae22fd7
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/action_with_ivars.erb
@@ -0,0 +1 @@
+<%= @my_ivar %> from index_with_ivars.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/helper_test.erb b/actionpack/test/abstract_controller/views/helper_test.erb
new file mode 100644
index 0000000000..8ae45cc195
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/helper_test.erb
@@ -0,0 +1 @@
+Hello <%= helpery_test %> : <%= included_method %>
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/index.erb b/actionpack/test/abstract_controller/views/index.erb
new file mode 100644
index 0000000000..cc1a8b8c85
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/index.erb
@@ -0,0 +1 @@
+Hello from index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/layouts/abstract_controller/testing/me4.erb b/actionpack/test/abstract_controller/views/layouts/abstract_controller/testing/me4.erb
new file mode 100644
index 0000000000..172dd56569
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/layouts/abstract_controller/testing/me4.erb
@@ -0,0 +1 @@
+Me4 Enter : <%= yield %> : Exit
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/layouts/application.erb b/actionpack/test/abstract_controller/views/layouts/application.erb
new file mode 100644
index 0000000000..27317140ad
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/layouts/application.erb
@@ -0,0 +1 @@
+Application Enter : <%= yield %> : Exit
\ No newline at end of file
diff --git a/actionpack/test/abstract_controller/views/naked_render.erb b/actionpack/test/abstract_controller/views/naked_render.erb
new file mode 100644
index 0000000000..1b3d03878b
--- /dev/null
+++ b/actionpack/test/abstract_controller/views/naked_render.erb
@@ -0,0 +1 @@
+Hello from naked_render.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index cdeee934d0..b07e6e5f3a 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -20,8 +20,7 @@ rescue LoadError
 end
 
 require 'action_controller'
-require 'action_controller/cgi_ext'
-require 'action_controller/test_process'
+require 'action_controller/testing/process'
 require 'action_view/test_case'
 
 # Show backtraces for deprecated behavior for quicker cleanup.
@@ -38,8 +37,4 @@ I18n.backend.store_translations 'pt-BR', {}
 ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
-ActionView::Base.cache_template_loading = true
 ActionController::Base.view_paths = FIXTURE_LOAD_PATH
-CACHED_VIEW_PATHS = ActionView::Base.cache_template_loading? ?
-                      ActionController::Base.view_paths :
-                      ActionController::Base.view_paths.map {|path| ActionView::Template::EagerPath.new(path.to_s)}
diff --git a/actionpack/test/activerecord/active_record_store_test.rb b/actionpack/test/activerecord/active_record_store_test.rb
index c98892edc1..34f18806a2 100644
--- a/actionpack/test/activerecord/active_record_store_test.rb
+++ b/actionpack/test/activerecord/active_record_store_test.rb
@@ -45,23 +45,27 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
     ActiveRecord::SessionStore.session_class.drop_table!
   end
 
-  def test_setting_and_getting_session_value
-    with_test_route_set do
-      get '/set_session_value'
-      assert_response :success
-      assert cookies['_session_id']
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: "bar"', response.body
-
-      get '/set_session_value', :foo => "baz"
-      assert_response :success
-      assert cookies['_session_id']
-
-      get '/get_session_value'
-      assert_response :success
-      assert_equal 'foo: "baz"', response.body
+  %w{ session sql_bypass }.each do |class_name|
+    define_method("test_setting_and_getting_session_value_with_#{class_name}_store") do
+      with_store class_name do
+        with_test_route_set do
+          get '/set_session_value'
+          assert_response :success
+          assert cookies['_session_id']
+
+          get '/get_session_value'
+          assert_response :success
+          assert_equal 'foo: "bar"', response.body
+
+          get '/set_session_value', :foo => "baz"
+          assert_response :success
+          assert cookies['_session_id']
+
+          get '/get_session_value'
+          assert_response :success
+          assert_equal 'foo: "baz"', response.body
+        end
+      end
     end
   end
 
@@ -171,4 +175,11 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
         yield
       end
     end
+
+    def with_store(class_name)
+      session_class, ActiveRecord::SessionStore.session_class =
+        ActiveRecord::SessionStore.session_class, "ActiveRecord::SessionStore::#{class_name.camelize}".constantize
+      yield
+      ActiveRecord::SessionStore.session_class = session_class
+    end
 end
diff --git a/actionpack/test/activerecord/polymorphic_routes_test.rb b/actionpack/test/activerecord/polymorphic_routes_test.rb
new file mode 100644
index 0000000000..35139fbb7f
--- /dev/null
+++ b/actionpack/test/activerecord/polymorphic_routes_test.rb
@@ -0,0 +1,394 @@
+require 'active_record_unit'
+
+class Task < ActiveRecord::Base
+  set_table_name 'projects'
+end
+
+class Step < ActiveRecord::Base
+  set_table_name 'projects'
+end
+
+class Bid < ActiveRecord::Base
+  set_table_name 'projects'
+end
+
+class Tax < ActiveRecord::Base
+  set_table_name 'projects'
+end
+
+class Fax < ActiveRecord::Base
+  set_table_name 'projects'
+end
+
+class Series < ActiveRecord::Base
+  set_table_name 'projects'
+end
+
+class PolymorphicRoutesTest < ActionController::TestCase
+  include ActionController::UrlWriter
+  self.default_url_options[:host] = 'example.com'
+
+  def setup
+    @project = Project.new
+    @task = Task.new
+    @step = Step.new
+    @bid = Bid.new
+    @tax = Tax.new
+    @fax = Fax.new
+    @series = Series.new
+  end
+
+  def test_with_record
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}", polymorphic_url(@project)
+    end
+  end
+
+  def test_with_new_record
+    with_test_routes do 
+      assert_equal "http://example.com/projects", polymorphic_url(@project)
+    end
+  end
+
+  def test_with_record_and_action
+    with_test_routes do 
+      assert_equal "http://example.com/projects/new", polymorphic_url(@project, :action => 'new')
+    end
+  end
+
+  def test_url_helper_prefixed_with_new
+    with_test_routes do 
+      assert_equal "http://example.com/projects/new", new_polymorphic_url(@project)
+    end
+  end
+
+  def test_url_helper_prefixed_with_edit
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}/edit", edit_polymorphic_url(@project)
+    end
+  end
+  
+  def test_url_helper_prefixed_with_edit_with_url_options
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}/edit?param1=10", edit_polymorphic_url(@project, :param1 => '10')
+    end
+  end
+  
+  def test_url_helper_with_url_options
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}?param1=10", polymorphic_url(@project, :param1 => '10')
+    end
+  end
+
+  def test_formatted_url_helper_is_deprecated
+    with_test_routes do
+      assert_deprecated do
+        formatted_polymorphic_url([@project, :pdf])
+      end
+    end
+  end
+  
+  def test_format_option
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}.pdf", polymorphic_url(@project, :format => :pdf)
+    end
+  end
+  
+  def test_format_option_with_url_options
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}.pdf?param1=10", polymorphic_url(@project, :format => :pdf, :param1 => '10')
+    end
+  end
+  
+  def test_id_and_format_option
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}.pdf", polymorphic_url(:id => @project, :format => :pdf)
+    end
+  end
+
+  def test_with_nested
+    with_test_routes do
+      @project.save
+      @task.save
+      assert_equal "http://example.com/projects/#{@project.id}/tasks/#{@task.id}", polymorphic_url([@project, @task])
+    end
+  end
+  
+  def test_with_nested_unsaved
+    with_test_routes do
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}/tasks", polymorphic_url([@project, @task])
+    end
+  end
+  
+  def test_new_with_array_and_namespace
+    with_admin_test_routes do 
+      assert_equal "http://example.com/admin/projects/new", polymorphic_url([:admin, @project], :action => 'new')
+    end
+  end
+  
+  def test_unsaved_with_array_and_namespace
+    with_admin_test_routes do 
+      assert_equal "http://example.com/admin/projects", polymorphic_url([:admin, @project])
+    end
+  end
+  
+  def test_nested_unsaved_with_array_and_namespace
+    with_admin_test_routes do 
+      @project.save
+      assert_equal "http://example.com/admin/projects/#{@project.id}/tasks", polymorphic_url([:admin, @project, @task])
+    end
+  end
+  
+  def test_nested_with_array_and_namespace
+    with_admin_test_routes do 
+      @project.save
+      @task.save
+      assert_equal "http://example.com/admin/projects/#{@project.id}/tasks/#{@task.id}", polymorphic_url([:admin, @project, @task])
+    end
+  end
+  
+  def test_ordering_of_nesting_and_namespace
+    with_admin_and_site_test_routes do 
+      @project.save
+      @task.save
+      @step.save
+      assert_equal "http://example.com/admin/projects/#{@project.id}/site/tasks/#{@task.id}/steps/#{@step.id}", polymorphic_url([:admin, @project, :site, @task, @step])
+    end
+  end
+  
+  def test_nesting_with_array_ending_in_singleton_resource
+    with_test_routes do
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}/bid", polymorphic_url([@project, :bid])
+    end
+  end
+  
+  def test_nesting_with_array_containing_singleton_resource
+    with_test_routes do
+      @project.save
+      @task.save
+      assert_equal "http://example.com/projects/#{@project.id}/bid/tasks/#{@task.id}", polymorphic_url([@project, :bid, @task])
+    end
+  end
+  
+  def test_nesting_with_array_containing_singleton_resource_and_format
+    with_test_routes do
+      @project.save
+      @task.save
+      assert_equal "http://example.com/projects/#{@project.id}/bid/tasks/#{@task.id}.pdf", polymorphic_url([@project, :bid, @task], :format => :pdf)
+    end
+  end
+  
+  def test_nesting_with_array_containing_namespace_and_singleton_resource
+    with_admin_test_routes do
+      @project.save
+      @task.save
+      assert_equal "http://example.com/admin/projects/#{@project.id}/bid/tasks/#{@task.id}", polymorphic_url([:admin, @project, :bid, @task])
+    end
+  end
+  
+  def test_nesting_with_array_containing_nil
+    with_test_routes do
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}/bid", polymorphic_url([@project, nil, :bid])
+    end
+  end
+  
+  def test_with_array_containing_single_object
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}", polymorphic_url([nil, @project])
+    end
+  end
+  
+  def test_with_array_containing_single_name
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects", polymorphic_url([:projects])
+    end
+  end
+  
+  def test_with_hash
+    with_test_routes do 
+      @project.save
+      assert_equal "http://example.com/projects/#{@project.id}", polymorphic_url(:id => @project)
+    end
+  end
+  
+  def test_polymorphic_path_accepts_options
+    with_test_routes do 
+      assert_equal "/projects/new", polymorphic_path(@project, :action => 'new')
+    end
+  end
+  
+  def test_polymorphic_path_does_not_modify_arguments
+    with_admin_test_routes do
+      @project.save
+      @task.save
+      object_array = [:admin, @project, @task]
+      assert_no_difference 'object_array.size' do
+        polymorphic_url(object_array)
+      end
+    end
+  end
+  
+  # Tests for names where .plural.singular doesn't round-trip
+  def test_with_irregular_plural_record
+    with_test_routes do 
+      @tax.save
+      assert_equal "http://example.com/taxes/#{@tax.id}", polymorphic_url(@tax)
+    end
+  end
+  
+  def test_with_irregular_plural_new_record
+    with_test_routes do 
+      assert_equal "http://example.com/taxes", polymorphic_url(@tax)
+    end
+  end
+  
+  def test_with_irregular_plural_record_and_action
+    with_test_routes do 
+      assert_equal "http://example.com/taxes/new", polymorphic_url(@tax, :action => 'new')
+    end
+  end
+  
+  def test_irregular_plural_url_helper_prefixed_with_new
+    with_test_routes do 
+      assert_equal "http://example.com/taxes/new", new_polymorphic_url(@tax)
+    end
+  end
+  
+  def test_irregular_plural_url_helper_prefixed_with_edit
+    with_test_routes do 
+      @tax.save
+      assert_equal "http://example.com/taxes/#{@tax.id}/edit", edit_polymorphic_url(@tax)
+    end
+  end
+  
+  def test_with_nested_irregular_plurals
+    with_test_routes do 
+      @tax.save
+      @fax.save
+      assert_equal "http://example.com/taxes/#{@tax.id}/faxes/#{@fax.id}", polymorphic_url([@tax, @fax])
+    end
+  end
+  
+  def test_with_nested_unsaved_irregular_plurals
+    with_test_routes do 
+      @tax.save
+      assert_equal "http://example.com/taxes/#{@tax.id}/faxes", polymorphic_url([@tax, @fax])
+    end
+  end
+  
+  def test_new_with_irregular_plural_array_and_namespace
+    with_admin_test_routes do 
+      assert_equal "http://example.com/admin/taxes/new", polymorphic_url([:admin, @tax], :action => 'new')
+    end
+  end
+  
+  def test_unsaved_with_irregular_plural_array_and_namespace
+    with_admin_test_routes do 
+      assert_equal "http://example.com/admin/taxes", polymorphic_url([:admin, @tax])
+    end
+  end
+  
+  def test_nesting_with_irregular_plurals_and_array_ending_in_singleton_resource
+    with_test_routes do 
+      @tax.save
+      assert_equal "http://example.com/taxes/#{@tax.id}/bid", polymorphic_url([@tax, :bid])
+    end
+  end
+  
+  def test_with_array_containing_single_irregular_plural_object
+    with_test_routes do 
+      @tax.save
+      assert_equal "http://example.com/taxes/#{@tax.id}", polymorphic_url([nil, @tax])
+    end
+  end
+  
+  def test_with_array_containing_single_name_irregular_plural
+    with_test_routes do 
+      @tax.save
+      assert_equal "http://example.com/taxes", polymorphic_url([:taxes])
+    end
+  end
+  
+ # Tests for uncountable names  
+  def test_uncountable_resource
+    with_test_routes do
+      @series.save
+      assert_equal "http://example.com/series/#{@series.id}", polymorphic_url(@series)
+    end
+  end
+
+  def with_test_routes(options = {})
+    with_routing do |set|
+      set.draw do |map|
+        map.resources :projects do |projects|
+          projects.resources :tasks
+          projects.resource :bid do |bid|
+            bid.resources :tasks
+          end
+        end
+        map.resources :taxes do |taxes|
+          taxes.resources :faxes
+          taxes.resource :bid
+        end
+        map.resources :series
+      end
+
+      ActionController::Routing::Routes.install_helpers(self.class)
+      yield
+    end
+  end
+  
+  def with_admin_test_routes(options = {})
+    with_routing do |set|
+      set.draw do |map|
+        map.namespace :admin do |admin|
+          admin.resources :projects do |projects|
+            projects.resources :tasks
+            projects.resource :bid do |bid|
+              bid.resources :tasks
+            end
+          end
+          admin.resources :taxes do |taxes|
+            taxes.resources :faxes
+          end
+          admin.resources :series
+        end
+      end
+
+      ActionController::Routing::Routes.install_helpers(self.class)
+      yield
+    end
+  end
+  
+  def with_admin_and_site_test_routes(options = {})
+    with_routing do |set|
+      set.draw do |map|
+        map.namespace :admin do |admin|
+          admin.resources :projects do |projects|
+            projects.namespace :site do |site|
+              site.resources :tasks do |tasks|
+                tasks.resources :steps
+              end
+            end
+          end
+        end
+      end
+
+      ActionController::Routing::Routes.install_helpers(self.class)
+      yield
+    end
+  end
+
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index cb7922efd2..96f7a42c9b 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -168,11 +168,13 @@ end
 class ActionPackAssertionsControllerTest < ActionController::TestCase
   # let's get this party started
   def setup
+    super
     ActionController::Routing::Routes.reload
     ActionController::Routing.use_controllers!(%w(action_pack_assertions admin/inner_module user content admin/user))
   end
 
   def teardown
+    super
     ActionController::Routing::Routes.reload
   end
 
diff --git a/actionpack/test/controller/addresses_render_test.rb b/actionpack/test/controller/addresses_render_test.rb
index 556b0593ea..2f092b6731 100644
--- a/actionpack/test/controller/addresses_render_test.rb
+++ b/actionpack/test/controller/addresses_render_test.rb
@@ -23,6 +23,7 @@ class AddressesTest < ActionController::TestCase
   tests AddressesTestController
 
   def setup
+    super
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb
index 298c7e4db3..ad17d1288b 100644
--- a/actionpack/test/controller/assert_select_test.rb
+++ b/actionpack/test/controller/assert_select_test.rb
@@ -66,12 +66,14 @@ class AssertSelectTest < ActionController::TestCase
   tests AssertSelectController
 
   def setup
+    super
     ActionMailer::Base.delivery_method = :test
     ActionMailer::Base.perform_deliveries = true
     ActionMailer::Base.deliveries = []
   end
 
   def teardown
+    super
     ActionMailer::Base.deliveries.clear
   end
 
diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb
index 9523189f41..f4517d06c4 100644
--- a/actionpack/test/controller/base_test.rb
+++ b/actionpack/test/controller/base_test.rb
@@ -170,6 +170,7 @@ class DefaultUrlOptionsTest < ActionController::TestCase
   tests DefaultUrlOptionsController
 
   def setup
+    super
     @request.host = 'www.example.com'
     rescue_action_in_public!
   end
@@ -193,6 +194,7 @@ class EmptyUrlOptionsTest < ActionController::TestCase
   tests NonEmptyController
 
   def setup
+    super
     @request.host = 'www.example.com'
     rescue_action_in_public!
   end
diff --git a/actionpack/test/controller/benchmark_test.rb b/actionpack/test/controller/benchmark_test.rb
index f9100a2313..66ebfcf20a 100644
--- a/actionpack/test/controller/benchmark_test.rb
+++ b/actionpack/test/controller/benchmark_test.rb
@@ -20,6 +20,7 @@ class BenchmarkTest < ActionController::TestCase
   end
 
   def setup
+    super
     # benchmark doesn't do anything unless a logger is set
     @controller.logger = MockLogger.new
     @request.host = "test.actioncontroller.i"
diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb
index 86dafd9221..b61a58dd09 100644
--- a/actionpack/test/controller/caching_test.rb
+++ b/actionpack/test/controller/caching_test.rb
@@ -44,6 +44,7 @@ end
 
 class PageCachingTest < ActionController::TestCase
   def setup
+    super
     ActionController::Base.perform_caching = true
 
     ActionController::Routing::Routes.draw do |map|
@@ -222,6 +223,7 @@ end
 
 class ActionCacheTest < ActionController::TestCase
   def setup
+    super
     reset!
     FileUtils.mkdir_p(FILE_STORE_PATH)
     @path_class = ActionController::Caching::Actions::ActionCachePath
@@ -483,6 +485,7 @@ end
 
 class FragmentCachingTest < ActionController::TestCase
   def setup
+    super
     ActionController::Base.perform_caching = true
     @store = ActiveSupport::Cache::MemoryStore.new
     ActionController::Base.cache_store = @store
@@ -615,6 +618,7 @@ end
 
 class FunctionalFragmentCachingTest < ActionController::TestCase
   def setup
+    super
     ActionController::Base.perform_caching = true
     @store = ActiveSupport::Cache::MemoryStore.new
     ActionController::Base.cache_store = @store
diff --git a/actionpack/test/controller/capture_test.rb b/actionpack/test/controller/capture_test.rb
index 6dfa0995eb..9a0976ca9f 100644
--- a/actionpack/test/controller/capture_test.rb
+++ b/actionpack/test/controller/capture_test.rb
@@ -27,6 +27,7 @@ class CaptureTest < ActionController::TestCase
   tests CaptureController
 
   def setup
+    super
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
diff --git a/actionpack/test/controller/content_type_test.rb b/actionpack/test/controller/content_type_test.rb
index 32c1757ef9..7377546631 100644
--- a/actionpack/test/controller/content_type_test.rb
+++ b/actionpack/test/controller/content_type_test.rb
@@ -54,6 +54,7 @@ class ContentTypeTest < ActionController::TestCase
   tests ContentTypeController
 
   def setup
+    super
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
@@ -136,10 +137,12 @@ class AcceptBasedContentTypeTest < ActionController::TestCase
   tests ContentTypeController
 
   def setup
+    super
     ActionController::Base.use_accept_header = true
   end
 
   def teardown
+    super
     ActionController::Base.use_accept_header = false
   end
 
diff --git a/actionpack/test/controller/cookie_test.rb b/actionpack/test/controller/cookie_test.rb
index 657be3c4e4..c861982698 100644
--- a/actionpack/test/controller/cookie_test.rb
+++ b/actionpack/test/controller/cookie_test.rb
@@ -6,6 +6,10 @@ class CookieTest < ActionController::TestCase
       cookies["user_name"] = "david"
     end
 
+    def set_with_with_escapable_characters
+      cookies["that & guy"] = "foo & bar => baz"
+    end
+
     def authenticate_for_fourteen_days
       cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
     end
@@ -44,6 +48,7 @@ class CookieTest < ActionController::TestCase
   tests TestController
 
   def setup
+    super
     @request.host = "www.nextangle.com"
   end
 
@@ -53,6 +58,12 @@ class CookieTest < ActionController::TestCase
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
+  def test_setting_with_escapable_characters
+    get :set_with_with_escapable_characters
+    assert_equal ["that+%26+guy=foo+%26+bar+%3D%3E+baz; path=/"], @response.headers["Set-Cookie"]
+    assert_equal({"that & guy" => "foo & bar => baz"}, @response.cookies)
+  end
+
   def test_setting_cookie_for_fourteen_days
     get :authenticate_for_fourteen_days
     assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index 7887b7110c..569d698a03 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -6,8 +6,8 @@ class DispatcherTest < Test::Unit::TestCase
   def setup
     ENV['REQUEST_METHOD'] = 'GET'
 
-    Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware|
-      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb"))
+    Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
+      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/middlewares.rb"))
       middleware.instance_eval(File.read(middlewares))
     end
 
@@ -46,8 +46,8 @@ class DispatcherTest < Test::Unit::TestCase
   end
 
   def test_failsafe_response
-    Dispatcher.any_instance.expects(:dispatch).raises('b00m')
-    ActionController::Failsafe.any_instance.expects(:log_failsafe_exception)
+    Dispatcher.any_instance.expects(:_call).raises('b00m')
+    ActionDispatch::Failsafe.any_instance.expects(:log_failsafe_exception)
 
     assert_nothing_raised do
       assert_equal [
@@ -94,7 +94,7 @@ class DispatcherTest < Test::Unit::TestCase
     def dispatch(cache_classes = true)
       ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
       Dispatcher.define_dispatcher_callbacks(cache_classes)
-      Dispatcher.new.call({})
+      Dispatcher.new.call({'rack.input' => StringIO.new('')})
     end
 
     def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
diff --git a/actionpack/test/controller/header_test.rb b/actionpack/test/controller/header_test.rb
deleted file mode 100644
index 33c14a187c..0000000000
--- a/actionpack/test/controller/header_test.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require 'abstract_unit'
-
-class HeaderTest < Test::Unit::TestCase
-  def setup
-    @headers = ActionController::Http::Headers.new("HTTP_CONTENT_TYPE"=>"text/plain")
-  end
-  
-  def test_content_type_works
-    assert_equal "text/plain", @headers["Content-Type"]
-    assert_equal "text/plain", @headers["content-type"]
-    assert_equal "text/plain", @headers["CONTENT_TYPE"]
-    assert_equal "text/plain", @headers["HTTP_CONTENT_TYPE"]    
-  end
-end
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
index 1575674e18..f2721e274d 100644
--- a/actionpack/test/controller/layout_test.rb
+++ b/actionpack/test/controller/layout_test.rb
@@ -37,6 +37,7 @@ end
 
 class LayoutAutoDiscoveryTest < ActionController::TestCase
   def setup
+    super
     @request.host = "www.nextangle.com"
   end
 
@@ -55,7 +56,7 @@ class LayoutAutoDiscoveryTest < ActionController::TestCase
   def test_third_party_template_library_auto_discovers_layout
     @controller = ThirdPartyTemplateLibraryController.new
     get :hello
-    assert_equal 'layouts/third_party_template_library.mab', @controller.active_layout.to_s
+    assert_equal 'layouts/third_party_template_library.mab', @controller.active_layout(true).to_s
     assert_equal 'layouts/third_party_template_library', @response.layout
     assert_response :success
     assert_equal 'Mab', @response.body
@@ -64,14 +65,14 @@ class LayoutAutoDiscoveryTest < ActionController::TestCase
   def test_namespaced_controllers_auto_detect_layouts
     @controller = ControllerNameSpace::NestedController.new
     get :hello
-    assert_equal 'layouts/controller_name_space/nested', @controller.active_layout.to_s
+    assert_equal 'layouts/controller_name_space/nested', @controller.active_layout(true).to_s
     assert_equal 'controller_name_space/nested.rhtml hello.rhtml', @response.body
   end
 
   def test_namespaced_controllers_auto_detect_layouts
     @controller = MultipleExtensions.new
     get :hello
-    assert_equal 'layouts/multiple_extensions.html.erb', @controller.active_layout.to_s
+    assert_equal 'layouts/multiple_extensions.html.erb', @controller.active_layout(true).to_s
     assert_equal 'multiple_extensions.html.erb hello.rhtml', @response.body.strip
   end
 end
@@ -94,6 +95,14 @@ class PrependsViewPathController < LayoutTest
   end
 end
 
+class OnlyLayoutController < LayoutTest
+  layout 'item', :only => "hello"
+end
+
+class ExceptLayoutController < LayoutTest
+  layout 'item', :except => "goodbye"
+end
+
 class SetsLayoutInRenderController < LayoutTest
   def hello
     render :layout => 'third_party_template_library'
@@ -118,6 +127,30 @@ class LayoutSetInResponseTest < ActionController::TestCase
     get :hello
     assert_equal 'layouts/item', @response.layout
   end
+  
+  def test_layout_only_exception_when_included
+    @controller = OnlyLayoutController.new
+    get :hello
+    assert_equal 'layouts/item', @response.layout
+  end
+
+  def test_layout_only_exception_when_excepted
+    @controller = OnlyLayoutController.new
+    get :goodbye
+    assert_equal nil, @response.layout
+  end
+
+  def test_layout_except_exception_when_included
+    @controller = ExceptLayoutController.new
+    get :hello
+    assert_equal 'layouts/item', @response.layout
+  end
+
+  def test_layout_except_exception_when_excepted
+    @controller = ExceptLayoutController.new
+    get :goodbye
+    assert_equal nil, @response.layout
+  end
 
   def test_layout_set_when_using_render
     @controller = SetsLayoutInRenderController.new
@@ -143,9 +176,11 @@ class LayoutSetInResponseTest < ActionController::TestCase
   end
 
   def test_layout_is_picked_from_the_controller_instances_view_path
-    @controller = PrependsViewPathController.new
-    get :hello
-    assert_equal 'layouts/alt', @response.layout
+    pending do
+      @controller = PrependsViewPathController.new
+      get :hello
+      assert_equal 'layouts/alt', @response.layout
+    end
   end
 
   def test_absolute_pathed_layout
@@ -201,4 +236,3 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/
     end
   end
 end
-
diff --git a/actionpack/test/controller/logging_test.rb b/actionpack/test/controller/logging_test.rb
index 3c936854dd..1f3ff4ef52 100644
--- a/actionpack/test/controller/logging_test.rb
+++ b/actionpack/test/controller/logging_test.rb
@@ -18,7 +18,10 @@ class LoggingTest < ActionController::TestCase
     end
   end
 
-  setup :set_logger
+  def setup
+    super
+    set_logger
+  end
 
   def test_logging_without_parameters
     get :show
diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime_responds_test.rb
index edd7162325..7cd5145a2f 100644
--- a/actionpack/test/controller/mime_responds_test.rb
+++ b/actionpack/test/controller/mime_responds_test.rb
@@ -166,11 +166,13 @@ class MimeControllerTest < ActionController::TestCase
   tests RespondToController
 
   def setup
+    super
     ActionController::Base.use_accept_header = true
     @request.host = "www.example.com"
   end
 
   def teardown
+    super
     ActionController::Base.use_accept_header = false
   end
 
@@ -437,15 +439,15 @@ class MimeControllerTest < ActionController::TestCase
         unless args.empty?
           @action = args.first[:action]
         end
-        response.body = "#{@action} - #{@template.template_format}"
+        response.body = "#{@action} - #{@template.formats}"
       end
     end
 
     get :using_defaults
-    assert_equal "using_defaults - html", @response.body
+    assert_equal "using_defaults - #{[:html].to_s}", @response.body
 
     get :using_defaults, :format => "xml"
-    assert_equal "using_defaults - xml", @response.body
+    assert_equal "using_defaults - #{[:xml].to_s}", @response.body
   end
 
   def test_format_with_custom_response_type
@@ -511,6 +513,7 @@ class MimeControllerLayoutsTest < ActionController::TestCase
   tests PostController
 
   def setup
+    super
     @request.host = "www.example.com"
   end
 
diff --git a/actionpack/test/controller/polymorphic_routes_test.rb b/actionpack/test/controller/polymorphic_routes_test.rb
deleted file mode 100644
index 146d703619..0000000000
--- a/actionpack/test/controller/polymorphic_routes_test.rb
+++ /dev/null
@@ -1,293 +0,0 @@
-require 'abstract_unit'
-
-class Article
-  attr_reader :id
-  def save; @id = 1 end
-  def new_record?; @id.nil? end
-  def name
-    model = self.class.name.downcase
-    @id.nil? ? "new #{model}" : "#{model} ##{@id}"
-  end
-end
-
-class Response < Article
-  def post_id; 1 end
-end
-
-class Tag < Article
-  def response_id; 1 end
-end
-
-class Tax
-  attr_reader :id
-  def save; @id = 1 end
-  def new_record?; @id.nil? end
-  def name
-    model = self.class.name.downcase
-    @id.nil? ? "new #{model}" : "#{model} ##{@id}"
-  end
-end
-
-class Fax < Tax
-  def store_id; 1 end
-end
-
-# TODO: test nested models
-class Response::Nested < Response; end
-
-class PolymorphicRoutesTest < ActiveSupport::TestCase
-  include ActionController::PolymorphicRoutes
-
-  def setup
-    @article = Article.new
-    @response = Response.new
-    @tax = Tax.new
-    @fax = Fax.new
-  end
-
-  def test_with_record
-    @article.save
-    expects(:article_url).with(@article)
-    polymorphic_url(@article)
-  end
-
-  def test_with_new_record
-    expects(:articles_url).with()
-    @article.expects(:new_record?).returns(true)
-    polymorphic_url(@article)
-  end
-
-  def test_with_record_and_action
-    expects(:new_article_url).with()
-    @article.expects(:new_record?).never
-    polymorphic_url(@article, :action => 'new')
-  end
-
-  def test_url_helper_prefixed_with_new
-    expects(:new_article_url).with()
-    new_polymorphic_url(@article)
-  end
-
-  def test_url_helper_prefixed_with_edit
-    @article.save
-    expects(:edit_article_url).with(@article)
-    edit_polymorphic_url(@article)
-  end
-
-  def test_url_helper_prefixed_with_edit_with_url_options
-    @article.save
-    expects(:edit_article_url).with(@article, :param1 => '10')
-    edit_polymorphic_url(@article, :param1 => '10')
-  end
-
-  def test_url_helper_with_url_options
-    @article.save
-    expects(:article_url).with(@article, :param1 => '10')
-    polymorphic_url(@article, :param1 => '10')
-  end
-
-  def test_formatted_url_helper_is_deprecated
-    expects(:articles_url).with(:format => :pdf)
-    assert_deprecated do
-      formatted_polymorphic_url([@article, :pdf])
-    end
-  end
-
-  def test_format_option
-    @article.save
-    expects(:article_url).with(@article, :format => :pdf)
-    polymorphic_url(@article, :format => :pdf)
-  end
-
-  def test_format_option_with_url_options
-    @article.save
-    expects(:article_url).with(@article, :format => :pdf, :param1 => '10')
-    polymorphic_url(@article, :format => :pdf, :param1 => '10')
-  end
-
-  def test_id_and_format_option
-    @article.save
-    expects(:article_url).with(:id => @article, :format => :pdf)
-    polymorphic_url(:id => @article, :format => :pdf)
-  end
-
-  def test_with_nested
-    @response.save
-    expects(:article_response_url).with(@article, @response)
-    polymorphic_url([@article, @response])
-  end
-
-  def test_with_nested_unsaved
-    expects(:article_responses_url).with(@article)
-    polymorphic_url([@article, @response])
-  end
-
-  def test_new_with_array_and_namespace
-    expects(:new_admin_article_url).with()
-    polymorphic_url([:admin, @article], :action => 'new')
-  end
-
-  def test_unsaved_with_array_and_namespace
-    expects(:admin_articles_url).with()
-    polymorphic_url([:admin, @article])
-  end
-
-  def test_nested_unsaved_with_array_and_namespace
-    @article.save
-    expects(:admin_article_url).with(@article)
-    polymorphic_url([:admin, @article])
-    expects(:admin_article_responses_url).with(@article)
-    polymorphic_url([:admin, @article, @response])
-  end
-
-  def test_nested_with_array_and_namespace
-    @response.save
-    expects(:admin_article_response_url).with(@article, @response)
-    polymorphic_url([:admin, @article, @response])
-
-    # a ridiculously long named route tests correct ordering of namespaces and nesting:
-    @tag = Tag.new
-    @tag.save
-    expects(:site_admin_article_response_tag_url).with(@article, @response, @tag)
-    polymorphic_url([:site, :admin, @article, @response, @tag])
-  end
-
-  def test_nesting_with_array_ending_in_singleton_resource
-    expects(:article_response_url).with(@article)
-    polymorphic_url([@article, :response])
-  end
-
-  def test_nesting_with_array_containing_singleton_resource
-    @tag = Tag.new
-    @tag.save
-    expects(:article_response_tag_url).with(@article, @tag)
-    polymorphic_url([@article, :response, @tag])
-  end
-
-  def test_nesting_with_array_containing_namespace_and_singleton_resource
-    @tag = Tag.new
-    @tag.save
-    expects(:admin_article_response_tag_url).with(@article, @tag)
-    polymorphic_url([:admin, @article, :response, @tag])
-  end
-
-  def test_nesting_with_array_containing_singleton_resource_and_format
-    @tag = Tag.new
-    @tag.save
-    expects(:article_response_tag_url).with(@article, @tag, :format => :pdf)
-    polymorphic_url([@article, :response, @tag], :format => :pdf)
-  end
-
-  def test_nesting_with_array_containing_singleton_resource_and_format_option
-    @tag = Tag.new
-    @tag.save
-    expects(:article_response_tag_url).with(@article, @tag, :format => :pdf)
-    polymorphic_url([@article, :response, @tag], :format => :pdf)
-  end
-
-  def test_nesting_with_array_containing_nil
-    expects(:article_response_url).with(@article)
-    polymorphic_url([@article, nil, :response])
-  end
-
-  def test_with_array_containing_single_object
-    @article.save
-    expects(:article_url).with(@article)
-    polymorphic_url([nil, @article])
-  end
-
-  def test_with_array_containing_single_name
-    @article.save
-    expects(:articles_url)
-    polymorphic_url([:articles])
-  end
-
-  # TODO: Needs to be updated to correctly know about whether the object is in a hash or not
-  def xtest_with_hash
-    expects(:article_url).with(@article)
-    @article.save
-    polymorphic_url(:id => @article)
-  end
-
-  def test_polymorphic_path_accepts_options
-    expects(:new_article_path).with()
-    polymorphic_path(@article, :action => :new)
-  end
-
-  def test_polymorphic_path_does_not_modify_arguments
-    expects(:admin_article_responses_url).with(@article)
-    path = [:admin, @article, @response]
-    assert_no_difference 'path.size' do
-      polymorphic_url(path)
-    end
-  end
-
-  # Tests for names where .plural.singular doesn't round-trip
-  def test_with_irregular_plural_record
-    @tax.save
-    expects(:taxis_url).with(@tax)
-    polymorphic_url(@tax)
-  end
-
-  def test_with_irregular_plural_new_record
-    expects(:taxes_url).with()
-    @tax.expects(:new_record?).returns(true)
-    polymorphic_url(@tax)
-  end
-
-  def test_with_irregular_plural_record_and_action
-    expects(:new_taxis_url).with()
-    @tax.expects(:new_record?).never
-    polymorphic_url(@tax, :action => 'new')
-  end
-
-  def test_irregular_plural_url_helper_prefixed_with_new
-    expects(:new_taxis_url).with()
-    new_polymorphic_url(@tax)
-  end
-
-  def test_irregular_plural_url_helper_prefixed_with_edit
-    @tax.save
-    expects(:edit_taxis_url).with(@tax)
-    edit_polymorphic_url(@tax)
-  end
-
-  def test_with_nested_irregular_plurals
-    @fax.save
-    expects(:taxis_faxis_url).with(@tax, @fax)
-    polymorphic_url([@tax, @fax])
-  end
-
-  def test_with_nested_unsaved_irregular_plurals
-    expects(:taxis_faxes_url).with(@tax)
-    polymorphic_url([@tax, @fax])
-  end
-
-  def test_new_with_irregular_plural_array_and_namespace
-    expects(:new_admin_taxis_url).with()
-    polymorphic_url([:admin, @tax], :action => 'new')
-  end
-
-  def test_unsaved_with_irregular_plural_array_and_namespace
-    expects(:admin_taxes_url).with()
-    polymorphic_url([:admin, @tax])
-  end
-
-  def test_nesting_with_irregular_plurals_and_array_ending_in_singleton_resource
-    expects(:taxis_faxis_url).with(@tax)
-    polymorphic_url([@tax, :faxis])
-  end
-
-  def test_with_array_containing_single_irregular_plural_object
-    @tax.save
-    expects(:taxis_url).with(@tax)
-    polymorphic_url([nil, @tax])
-  end
-
-  def test_with_array_containing_single_name_irregular_plural
-    @tax.save
-    expects(:taxes_url)
-    polymorphic_url([:taxes])
-  end
-
-end
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index a52931565d..9a34bcebe6 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -315,13 +315,6 @@ class TestController < ActionController::Base
   def render_implicit_html_template_from_xhr_request
   end
 
-  def render_implicit_js_template_without_layout
-  end
-
-  def render_html_explicit_template_and_layout
-    render :template => 'test/render_implicit_html_template_from_xhr_request', :layout => 'layouts/default_html'
-  end
-
   def formatted_html_erb
   end
 
@@ -390,7 +383,7 @@ class TestController < ActionController::Base
   end
 
   def accessing_params_in_template_with_layout
-    render :layout => nil, :inline =>  "Hello: <%= params[:name] %>"
+    render :layout => true, :inline =>  "Hello: <%= params[:name] %>"
   end
 
   def render_with_explicit_template
@@ -737,8 +730,6 @@ class TestController < ActionController::Base
              "delete_with_js", "update_page", "update_page_with_instance_variables"
 
           "layouts/standard"
-        when "render_implicit_js_template_without_layout"
-          "layouts/default_html"
         when "action_talk_to_layout", "layout_overriding_layout"
           "layouts/talk_from_action"
         when "render_implicit_html_template_from_xhr_request"
@@ -753,6 +744,7 @@ class RenderTest < ActionController::TestCase
   def setup
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
+    super
     @controller.logger = Logger.new(nil)
 
     @request.host = "www.nextangle.com"
@@ -836,11 +828,6 @@ class RenderTest < ActionController::TestCase
     assert_equal "<html>hello world, I'm here!</html>", @response.body
   end
 
-  def test_xhr_with_render_text_and_layout
-    xhr :get, :render_text_hello_world_with_layout
-    assert_equal "<html>hello world, I'm here!</html>", @response.body
-  end
-
   def test_do_with_render_action_and_layout_false
     get :hello_world_with_layout_false
     assert_equal 'Hello world!', @response.body
@@ -1081,18 +1068,17 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_should_implicitly_render_html_template_from_xhr_request
-    xhr :get, :render_implicit_html_template_from_xhr_request
-    assert_equal "XHR!\nHello HTML!", @response.body
-  end
-
-  def test_should_render_explicit_html_template_with_html_layout
-    xhr :get, :render_html_explicit_template_and_layout
-    assert_equal "<html>Hello HTML!</html>\n", @response.body
+    pending do
+      xhr :get, :render_implicit_html_template_from_xhr_request
+      assert_equal "XHR!\nHello HTML!", @response.body
+    end
   end
 
   def test_should_implicitly_render_js_template_without_layout
-    get :render_implicit_js_template_without_layout, :format => :js
-    assert_no_match /<html>/, @response.body
+    pending do
+      get :render_implicit_js_template_without_layout, :format => :js
+      assert_no_match %r{<html>}, @response.body
+    end
   end
 
   def test_should_render_formatted_template
@@ -1308,7 +1294,7 @@ class RenderTest < ActionController::TestCase
     assert !@response.headers.include?('Content-Length')
     assert_response :no_content
 
-    ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.each do |status, code|
+    ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE.each do |status, code|
       get :head_with_symbolic_status, :status => status.to_s
       assert_equal code, @response.response_code
       assert_response status
@@ -1316,7 +1302,7 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_head_with_integer_status
-    ActionController::StatusCodes::STATUS_CODES.each do |code, message|
+    ActionDispatch::StatusCodes::STATUS_CODES.each do |code, message|
       get :head_with_integer_status, :status => code.to_s
       assert_equal message, @response.message
     end
@@ -1574,6 +1560,7 @@ class EtagRenderTest < ActionController::TestCase
   tests TestController
 
   def setup
+    super
     @request.host = "www.nextangle.com"
     @expected_bang_etag = etag_for(expand_key([:foo, 123]))
   end
@@ -1684,6 +1671,7 @@ class LastModifiedRenderTest < ActionController::TestCase
   tests TestController
 
   def setup
+    super
     @request.host = "www.nextangle.com"
     @last_modified = Time.now.utc.beginning_of_day.httpdate
   end
@@ -1739,6 +1727,7 @@ class RenderingLoggingTest < ActionController::TestCase
   tests TestController
 
   def setup
+    super
     @request.host = "www.nextangle.com"
   end
 
@@ -1746,7 +1735,7 @@ class RenderingLoggingTest < ActionController::TestCase
     @controller.logger = MockLogger.new
     get :layout_test
     logged = @controller.logger.logged.find_all {|l| l =~ /render/i }
-    assert_equal "Rendering template within layouts/standard", logged[0]
-    assert_equal "Rendering test/hello_world", logged[1]
+    assert_equal "Rendering test/hello_world", logged[0]
+    assert_equal "Rendering template within layouts/standard", logged[1]
   end
 end
diff --git a/actionpack/test/controller/request/test_request_test.rb b/actionpack/test/controller/request/test_request_test.rb
new file mode 100644
index 0000000000..81551b4ba7
--- /dev/null
+++ b/actionpack/test/controller/request/test_request_test.rb
@@ -0,0 +1,35 @@
+require 'abstract_unit'
+require 'stringio'
+
+class ActionController::TestRequestTest < ActiveSupport::TestCase
+
+  def setup
+    @request = ActionController::TestRequest.new
+  end
+
+  def test_test_request_has_session_options_initialized
+    assert @request.session_options
+  end
+  
+  Rack::Session::Abstract::ID::DEFAULT_OPTIONS.each_key do |option|
+    test "test_rack_default_session_options_#{option}_exists_in_session_options_and_is_default" do
+      assert_equal(Rack::Session::Abstract::ID::DEFAULT_OPTIONS[option], 
+                   @request.session_options[option], 
+                   "Missing rack session default option #{option} in request.session_options")
+    end
+    test "test_rack_default_session_options_#{option}_exists_in_session_options" do
+      assert(@request.session_options.has_key?(option), 
+                   "Missing rack session option #{option} in request.session_options")
+    end
+  end
+  
+  def test_session_id_exists_by_default
+    assert_not_nil(@request.session_options[:id])
+  end
+  
+  def test_session_id_different_on_each_call
+    prev_id = 
+    assert_not_equal(@request.session_options[:id], ActionController::TestRequest.new.session_options[:id])
+  end
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index 835e73e3ab..83925ed4db 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -151,14 +151,10 @@ module RequestForgeryProtectionTests
       delete :index, :format => 'xml'
     end
   end
-
+  
   def test_should_allow_xhr_post_without_token
     assert_nothing_raised { xhr :post, :index }
   end
-  def test_should_not_allow_xhr_post_with_html_without_token
-    @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raise(ActionController::InvalidAuthenticityToken) { xhr :post, :index }
-  end
   
   def test_should_allow_xhr_put_without_token
     assert_nothing_raised { xhr :put, :index }
@@ -168,6 +164,11 @@ module RequestForgeryProtectionTests
     assert_nothing_raised { xhr :delete, :index }
   end
   
+  def test_should_allow_xhr_post_with_encoded_form_content_type_without_token
+    @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
+    assert_nothing_raised { xhr :post, :index }
+  end
+  
   def test_should_allow_post_with_token
     post :index, :authenticity_token => @token
     assert_response :success
diff --git a/actionpack/test/controller/request_test.rb b/actionpack/test/controller/request_test.rb
deleted file mode 100644
index c72f885a05..0000000000
--- a/actionpack/test/controller/request_test.rb
+++ /dev/null
@@ -1,407 +0,0 @@
-require 'abstract_unit'
-
-class RequestTest < ActiveSupport::TestCase
-  def setup
-    ActionController::Base.relative_url_root = nil
-    @request = ActionController::TestRequest.new
-  end
-
-  def teardown
-    ActionController::Base.relative_url_root = nil
-  end
-
-  def test_remote_ip
-    assert_equal '0.0.0.0', @request.remote_ip
-
-    @request.remote_addr = '1.2.3.4'
-    assert_equal '1.2.3.4', @request.remote_ip
-
-    @request.remote_addr = '1.2.3.4,3.4.5.6'
-    assert_equal '1.2.3.4', @request.remote_ip
-
-    @request.env['HTTP_CLIENT_IP'] = '2.3.4.5'
-    assert_equal '1.2.3.4', @request.remote_ip
-
-    @request.remote_addr = '192.168.0.1'
-    assert_equal '2.3.4.5', @request.remote_ip
-    @request.env.delete 'HTTP_CLIENT_IP'
-
-    @request.remote_addr = '1.2.3.4'
-    @request.env['HTTP_X_FORWARDED_FOR'] = '3.4.5.6'
-    assert_equal '1.2.3.4', @request.remote_ip
-
-    @request.remote_addr = '127.0.0.1'
-    @request.env['HTTP_X_FORWARDED_FOR'] = '3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = 'unknown,3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '172.16.0.1,3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '192.168.0.1,3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '10.0.0.1,3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '10.0.0.1, 10.0.0.1, 3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '127.0.0.1,3.4.5.6'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = 'unknown,192.168.0.1'
-    assert_equal 'unknown', @request.remote_ip
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '9.9.9.9, 3.4.5.6, 10.0.0.1, 172.31.4.4'
-    assert_equal '3.4.5.6', @request.remote_ip
-
-    @request.env['HTTP_CLIENT_IP'] = '8.8.8.8'
-    e = assert_raise(ActionController::ActionControllerError) {
-      @request.remote_ip
-    }
-    assert_match /IP spoofing attack/, e.message
-    assert_match /HTTP_X_FORWARDED_FOR="9.9.9.9, 3.4.5.6, 10.0.0.1, 172.31.4.4"/, e.message
-    assert_match /HTTP_CLIENT_IP="8.8.8.8"/, e.message
-
-    # turn IP Spoofing detection off.
-    # This is useful for sites that are aimed at non-IP clients.  The typical
-    # example is WAP.  Since the cellular network is not IP based, it's a
-    # leap of faith to assume that their proxies are ever going to set the
-    # HTTP_CLIENT_IP/HTTP_X_FORWARDED_FOR headers properly.
-    ActionController::Base.ip_spoofing_check = false
-    assert_equal('8.8.8.8', @request.remote_ip)
-    ActionController::Base.ip_spoofing_check = true
-
-    @request.env['HTTP_X_FORWARDED_FOR'] = '8.8.8.8, 9.9.9.9'
-    assert_equal '8.8.8.8', @request.remote_ip
-
-    @request.env.delete 'HTTP_CLIENT_IP'
-    @request.env.delete 'HTTP_X_FORWARDED_FOR'
-  end
-
-  def test_domains
-    @request.host = "www.rubyonrails.org"
-    assert_equal "rubyonrails.org", @request.domain
-
-    @request.host = "www.rubyonrails.co.uk"
-    assert_equal "rubyonrails.co.uk", @request.domain(2)
-
-    @request.host = "192.168.1.200"
-    assert_nil @request.domain
-
-    @request.host = "foo.192.168.1.200"
-    assert_nil @request.domain
-
-    @request.host = "192.168.1.200.com"
-    assert_equal "200.com", @request.domain
-
-    @request.host = nil
-    assert_nil @request.domain
-  end
-
-  def test_subdomains
-    @request.host = "www.rubyonrails.org"
-    assert_equal %w( www ), @request.subdomains
-
-    @request.host = "www.rubyonrails.co.uk"
-    assert_equal %w( www ), @request.subdomains(2)
-
-    @request.host = "dev.www.rubyonrails.co.uk"
-    assert_equal %w( dev www ), @request.subdomains(2)
-
-    @request.host = "foobar.foobar.com"
-    assert_equal %w( foobar ), @request.subdomains
-
-    @request.host = "192.168.1.200"
-    assert_equal [], @request.subdomains
-
-    @request.host = "foo.192.168.1.200"
-    assert_equal [], @request.subdomains
-
-    @request.host = "192.168.1.200.com"
-    assert_equal %w( 192 168 1 ), @request.subdomains
-
-    @request.host = nil
-    assert_equal [], @request.subdomains
-  end
-
-  def test_port_string
-    @request.port = 80
-    assert_equal "", @request.port_string
-
-    @request.port = 8080
-    assert_equal ":8080", @request.port_string
-  end
-
-  def test_request_uri
-    @request.env['SERVER_SOFTWARE'] = 'Apache 42.342.3432'
-
-    @request.set_REQUEST_URI "http://www.rubyonrails.org/path/of/some/uri?mapped=1"
-    assert_equal "/path/of/some/uri?mapped=1", @request.request_uri
-    assert_equal "/path/of/some/uri", @request.path
-
-    @request.set_REQUEST_URI "http://www.rubyonrails.org/path/of/some/uri"
-    assert_equal "/path/of/some/uri", @request.request_uri
-    assert_equal "/path/of/some/uri", @request.path
-
-    @request.set_REQUEST_URI "/path/of/some/uri"
-    assert_equal "/path/of/some/uri", @request.request_uri
-    assert_equal "/path/of/some/uri", @request.path
-
-    @request.set_REQUEST_URI "/"
-    assert_equal "/", @request.request_uri
-    assert_equal "/", @request.path
-
-    @request.set_REQUEST_URI "/?m=b"
-    assert_equal "/?m=b", @request.request_uri
-    assert_equal "/", @request.path
-
-    @request.set_REQUEST_URI "/"
-    @request.env['SCRIPT_NAME'] = "/dispatch.cgi"
-    assert_equal "/", @request.request_uri
-    assert_equal "/", @request.path
-
-    ActionController::Base.relative_url_root = "/hieraki"
-    @request.set_REQUEST_URI "/hieraki/"
-    @request.env['SCRIPT_NAME'] = "/hieraki/dispatch.cgi"
-    assert_equal "/hieraki/", @request.request_uri
-    assert_equal "/", @request.path
-    ActionController::Base.relative_url_root = nil
-
-    ActionController::Base.relative_url_root = "/collaboration/hieraki"
-    @request.set_REQUEST_URI "/collaboration/hieraki/books/edit/2"
-    @request.env['SCRIPT_NAME'] = "/collaboration/hieraki/dispatch.cgi"
-    assert_equal "/collaboration/hieraki/books/edit/2", @request.request_uri
-    assert_equal "/books/edit/2", @request.path
-    ActionController::Base.relative_url_root = nil
-
-    # The following tests are for when REQUEST_URI is not supplied (as in IIS)
-    @request.env['PATH_INFO'] = "/path/of/some/uri?mapped=1"
-    @request.env['SCRIPT_NAME'] = nil #"/path/dispatch.rb"
-    @request.set_REQUEST_URI nil
-    assert_equal "/path/of/some/uri?mapped=1", @request.request_uri
-    assert_equal "/path/of/some/uri", @request.path
-
-    ActionController::Base.relative_url_root = '/path'
-    @request.env['PATH_INFO'] = "/path/of/some/uri?mapped=1"
-    @request.env['SCRIPT_NAME'] = "/path/dispatch.rb"
-    @request.set_REQUEST_URI nil
-    assert_equal "/path/of/some/uri?mapped=1", @request.request_uri
-    assert_equal "/of/some/uri", @request.path
-    ActionController::Base.relative_url_root = nil
-
-    @request.env['PATH_INFO'] = "/path/of/some/uri"
-    @request.env['SCRIPT_NAME'] = nil
-    @request.set_REQUEST_URI nil
-    assert_equal "/path/of/some/uri", @request.request_uri
-    assert_equal "/path/of/some/uri", @request.path
-
-    @request.env['PATH_INFO'] = "/"
-    @request.set_REQUEST_URI nil
-    assert_equal "/", @request.request_uri
-    assert_equal "/", @request.path
-
-    @request.env['PATH_INFO'] = "/?m=b"
-    @request.set_REQUEST_URI nil
-    assert_equal "/?m=b", @request.request_uri
-    assert_equal "/", @request.path
-
-    @request.env['PATH_INFO'] = "/"
-    @request.env['SCRIPT_NAME'] = "/dispatch.cgi"
-    @request.set_REQUEST_URI nil
-    assert_equal "/", @request.request_uri
-    assert_equal "/", @request.path
-
-    ActionController::Base.relative_url_root = '/hieraki'
-    @request.env['PATH_INFO'] = "/hieraki/"
-    @request.env['SCRIPT_NAME'] = "/hieraki/dispatch.cgi"
-    @request.set_REQUEST_URI nil
-    assert_equal "/hieraki/", @request.request_uri
-    assert_equal "/", @request.path
-    ActionController::Base.relative_url_root = nil
-
-    @request.set_REQUEST_URI '/hieraki/dispatch.cgi'
-    ActionController::Base.relative_url_root = '/hieraki'
-    assert_equal "/dispatch.cgi", @request.path
-    ActionController::Base.relative_url_root = nil
-
-    @request.set_REQUEST_URI '/hieraki/dispatch.cgi'
-    ActionController::Base.relative_url_root = '/foo'
-    assert_equal "/hieraki/dispatch.cgi", @request.path
-    ActionController::Base.relative_url_root = nil
-
-    # This test ensures that Rails uses REQUEST_URI over PATH_INFO
-    ActionController::Base.relative_url_root = nil
-    @request.env['REQUEST_URI'] = "/some/path"
-    @request.env['PATH_INFO'] = "/another/path"
-    @request.env['SCRIPT_NAME'] = "/dispatch.cgi"
-    assert_equal "/some/path", @request.request_uri
-    assert_equal "/some/path", @request.path
-  end
-
-  def test_host_with_default_port
-    @request.host = "rubyonrails.org"
-    @request.port = 80
-    assert_equal "rubyonrails.org", @request.host_with_port
-  end
-
-  def test_host_with_non_default_port
-    @request.host = "rubyonrails.org"
-    @request.port = 81
-    assert_equal "rubyonrails.org:81", @request.host_with_port
-  end
-
-  def test_server_software
-    assert_equal nil, @request.server_software
-
-    @request.env['SERVER_SOFTWARE'] = 'Apache3.422'
-    assert_equal 'apache', @request.server_software
-
-    @request.env['SERVER_SOFTWARE'] = 'lighttpd(1.1.4)'
-    assert_equal 'lighttpd', @request.server_software
-  end
-
-  def test_xml_http_request
-    assert !@request.xml_http_request?
-    assert !@request.xhr?
-
-    @request.env['HTTP_X_REQUESTED_WITH'] = "DefinitelyNotAjax1.0"
-    assert !@request.xml_http_request?
-    assert !@request.xhr?
-
-    @request.env['HTTP_X_REQUESTED_WITH'] = "XMLHttpRequest"
-    assert @request.xml_http_request?
-    assert @request.xhr?
-  end
-
-  def test_reports_ssl
-    assert !@request.ssl?
-    @request.env['HTTPS'] = 'on'
-    assert @request.ssl?
-  end
-
-  def test_reports_ssl_when_proxied_via_lighttpd
-    assert !@request.ssl?
-    @request.env['HTTP_X_FORWARDED_PROTO'] = 'https'
-    assert @request.ssl?
-  end
-
-  def test_symbolized_request_methods
-    [:get, :post, :put, :delete].each do |method|
-      self.request_method = method
-      assert_equal method, @request.method
-    end
-  end
-
-  def test_invalid_http_method_raises_exception
-    assert_raise(ActionController::UnknownHttpMethod) do
-      self.request_method = :random_method
-      @request.request_method
-    end
-  end
-
-  def test_allow_method_hacking_on_post
-    [:get, :head, :options, :put, :post, :delete].each do |method|
-      self.request_method = method
-      assert_equal(method == :head ? :get : method, @request.method)
-    end
-  end
-
-  def test_invalid_method_hacking_on_post_raises_exception
-    assert_raise(ActionController::UnknownHttpMethod) do
-      self.request_method = :_random_method
-      @request.request_method
-    end
-  end
-
-  def test_restrict_method_hacking
-    @request.instance_eval { @parameters = { :_method => 'put' } }
-    [:get, :put, :delete].each do |method|
-      self.request_method = method
-      assert_equal method, @request.method
-    end
-  end
-
-  def test_head_masquerading_as_get
-    self.request_method = :head
-    assert_equal :get, @request.method
-    assert @request.get?
-    assert @request.head?
-  end
-
-  def test_xml_format
-    @request.instance_eval { @parameters = { :format => 'xml' } }
-    assert_equal Mime::XML, @request.format
-  end
-
-  def test_xhtml_format
-    @request.instance_eval { @parameters = { :format => 'xhtml' } }
-    assert_equal Mime::HTML, @request.format
-  end
-
-  def test_txt_format
-    @request.instance_eval { @parameters = { :format => 'txt' } }
-    assert_equal Mime::TEXT, @request.format
-  end
-
-  def test_nil_format
-    ActionController::Base.use_accept_header, old =
-      false, ActionController::Base.use_accept_header
-
-    @request.instance_eval { @parameters = {} }
-    @request.env["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest"
-    assert @request.xhr?
-    assert_equal Mime::JS, @request.format
-
-  ensure
-    ActionController::Base.use_accept_header = old
-  end
-
-  def test_content_type
-    @request.env["CONTENT_TYPE"] = "text/html"
-    assert_equal Mime::HTML, @request.content_type
-  end
-
-  def test_format_assignment_should_set_format
-    @request.instance_eval { self.format = :txt }
-    assert !@request.format.xml?
-    @request.instance_eval { self.format = :xml }
-    assert @request.format.xml?
-  end
-
-  def test_content_no_type
-    assert_equal nil, @request.content_type
-  end
-
-  def test_content_type_xml
-    @request.env["CONTENT_TYPE"] = "application/xml"
-    assert_equal Mime::XML, @request.content_type
-  end
-
-  def test_content_type_with_charset
-    @request.env["CONTENT_TYPE"] = "application/xml; charset=UTF-8"
-    assert_equal Mime::XML, @request.content_type
-  end
-
-  def test_user_agent
-    assert_not_nil @request.user_agent
-  end
-
-  def test_parameters
-    @request.stubs(:request_parameters).returns({ "foo" => 1 })
-    @request.stubs(:query_parameters).returns({ "bar" => 2 })
-
-    assert_equal({"foo" => 1, "bar" => 2}, @request.parameters)
-    assert_equal({"foo" => 1}, @request.request_parameters)
-    assert_equal({"bar" => 2}, @request.query_parameters)
-  end
-
-  protected
-    def request_method=(method)
-      @request.env['REQUEST_METHOD'] = method.to_s.upcase
-      @request.request_method = nil # Reset the ivar cache
-    end
-end
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index 5709f37e05..894420a910 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -141,8 +141,11 @@ end
 class RescueControllerTest < ActionController::TestCase
   FIXTURE_PUBLIC = "#{File.dirname(__FILE__)}/../fixtures".freeze
 
-  setup :set_all_requests_local
-  setup :populate_exception_object
+  def setup
+    super
+    set_all_requests_local
+    populate_exception_object
+  end
 
   def set_all_requests_local
     RescueController.consider_all_requests_local = true
@@ -397,22 +400,6 @@ class RescueControllerTest < ActionController::TestCase
     assert_equal "RescueController::ResourceUnavailableToRescueAsString", @response.body
   end
 
-  def test_rescue_dispatcher_exceptions
-    env = @request.env
-    env["action_controller.rescue.request"] = @request
-    env["action_controller.rescue.response"] = @response
-
-    RescueController.call_with_exception(env, ActionController::RoutingError.new("Route not found"))
-    assert_equal "no way", @response.body
-  end
-
-  def test_rescue_dispatcher_exceptions_without_request_set
-    @request.env['REQUEST_URI'] = '/no_way'
-    response = RescueController.call_with_exception(@request.env, ActionController::RoutingError.new("Route not found"))
-    assert_kind_of ActionController::Response, response
-    assert_equal "no way", response.body
-  end
-
   protected
     def with_all_requests_local(local = true)
       old_local, ActionController::Base.consider_all_requests_local =
@@ -534,3 +521,83 @@ class ControllerInheritanceRescueControllerTest < ActionController::TestCase
     assert_response :created
   end
 end
+
+class ApplicationController < ActionController::Base
+  rescue_from ActionController::RoutingError do
+    render :text => 'no way'
+  end
+end
+
+class RescueTest < ActionController::IntegrationTest
+  class TestController < ActionController::Base
+    class RecordInvalid < StandardError
+      def message
+        'invalid'
+      end
+    end
+    rescue_from RecordInvalid, :with => :show_errors
+
+    def foo
+      render :text => "foo"
+    end
+
+    def invalid
+      raise RecordInvalid
+    end
+
+    def b00m
+      raise 'b00m'
+    end
+
+    protected
+      def show_errors(exception)
+        render :text => exception.message
+      end
+  end
+
+  test 'normal request' do
+    with_test_routing do
+      get '/foo'
+      assert_equal 'foo', response.body
+    end
+  end
+
+  test 'rescue exceptions inside controller' do
+    with_test_routing do
+      get '/invalid'
+      assert_equal 'invalid', response.body
+    end
+  end
+
+  test 'rescue routing exceptions' do
+    assert_equal 1, ApplicationController.rescue_handlers.length
+
+    begin
+      with_test_routing do
+        get '/no_way'
+        assert_equal 'no way', response.body
+      end
+    ensure
+      ActionController::Base.rescue_handlers.clear
+    end
+  end
+
+  test 'unrescued exception' do
+    with_test_routing do
+      get '/b00m'
+      assert_match(/Action Controller: Exception caught/, response.body)
+    end
+  end
+
+  private
+    def with_test_routing
+      with_routing do |set|
+        set.draw do |map|
+          map.connect 'foo', :controller => "rescue_test/test", :action => 'foo'
+          map.connect 'invalid', :controller => "rescue_test/test", :action => 'invalid'
+          map.connect 'b00m', :controller => "rescue_test/test", :action => 'b00m'
+        end
+        yield
+      end
+    end
+end
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 3d1904fee9..2e14a0a32c 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -155,7 +155,7 @@ class SendFileTest < ActionController::TestCase
     define_method "test_default_send_#{method}_status" do
       @controller.options = { :stream => false }
       assert_nothing_raised { assert_not_nil process(method) }
-      assert_equal ActionController::Base::DEFAULT_RENDER_STATUS_CODE, @response.status
+      assert_equal ActionController::DEFAULT_RENDER_STATUS_CODE, @response.status
     end
   end
 end
diff --git a/actionpack/test/controller/test_test.rb b/actionpack/test/controller/test_test.rb
index 65c894c2e7..124e259ef6 100644
--- a/actionpack/test/controller/test_test.rb
+++ b/actionpack/test/controller/test_test.rb
@@ -119,6 +119,7 @@ XML
   end
 
   def setup
+    super
     @controller = TestController.new
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
@@ -127,6 +128,7 @@ XML
   end
 
   def teardown
+    super
     ActionController::Routing::Routes.reload
   end
 
@@ -515,6 +517,14 @@ XML
     assert_nil @request.instance_variable_get("@request_method")
   end
 
+  def test_params_reset_after_post_request
+    post :no_op, :foo => "bar"
+    assert_equal "bar", @request.params[:foo]
+    @request.recycle!
+    post :no_op
+    assert @request.params[:foo].blank?
+  end
+
   %w(controller response request).each do |variable|
     %w(get post put delete head process).each do |method|
       define_method("test_#{variable}_missing_for_#{method}_raises_error") do
@@ -635,7 +645,7 @@ class CleanBacktraceTest < ActionController::TestCase
   end
 
   def test_should_clean_assertion_lines_from_backtrace
-    path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller")
+    path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller/testing")
     exception = ActiveSupport::TestCase::Assertion.new('message')
     exception.set_backtrace ["#{path}/abc", "#{path}/assertions/def"]
     clean_backtrace { raise exception }
diff --git a/actionpack/test/controller/view_paths_test.rb b/actionpack/test/controller/view_paths_test.rb
index 8ea13fbe98..1539f8f506 100644
--- a/actionpack/test/controller/view_paths_test.rb
+++ b/actionpack/test/controller/view_paths_test.rb
@@ -29,8 +29,8 @@ class ViewLoadPathsTest < ActionController::TestCase
 
     @controller = TestController.new
     # Following is needed in order to setup @controller.template object properly
-    @controller.send :initialize_template_class, @response
     @controller.send :assign_shortcuts, @request, @response
+    @controller.send :initialize_template_class, @response
 
     # Track the last warning.
     @old_behavior = ActiveSupport::Deprecation.behavior
@@ -41,7 +41,7 @@ class ViewLoadPathsTest < ActionController::TestCase
   def teardown
     ActiveSupport::Deprecation.behavior = @old_behavior
   end
-  
+
   def test_template_load_path_was_set_correctly
     assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
diff --git a/actionpack/test/dispatch/header_test.rb b/actionpack/test/dispatch/header_test.rb
new file mode 100644
index 0000000000..ec6ba494dc
--- /dev/null
+++ b/actionpack/test/dispatch/header_test.rb
@@ -0,0 +1,16 @@
+require 'abstract_unit'
+
+class HeaderTest < ActiveSupport::TestCase
+  def setup
+    @headers = ActionDispatch::Http::Headers.new(
+      "HTTP_CONTENT_TYPE" => "text/plain"
+    )
+  end
+
+  test "content type" do
+    assert_equal "text/plain", @headers["Content-Type"]
+    assert_equal "text/plain", @headers["content-type"]
+    assert_equal "text/plain", @headers["CONTENT_TYPE"]
+    assert_equal "text/plain", @headers["HTTP_CONTENT_TYPE"]
+  end
+end
diff --git a/actionpack/test/controller/middleware_stack_test.rb b/actionpack/test/dispatch/middleware_stack_test.rb
index 918231013a..f4e18308ae 100644
--- a/actionpack/test/controller/middleware_stack_test.rb
+++ b/actionpack/test/dispatch/middleware_stack_test.rb
@@ -6,7 +6,7 @@ class MiddlewareStackTest < ActiveSupport::TestCase
   class BazMiddleware; end
 
   def setup
-    @stack = ActionController::MiddlewareStack.new
+    @stack = ActionDispatch::MiddlewareStack.new
     @stack.use FooMiddleware
     @stack.use BarMiddleware
   end
diff --git a/actionpack/test/controller/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index c7faa621d9..2fdf4819bb 100644
--- a/actionpack/test/controller/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -1,57 +1,60 @@
 require 'abstract_unit'
 
-class MimeTypeTest < Test::Unit::TestCase
-  Mime::Type.register "image/png", :png
-  Mime::Type.register "application/pdf", :pdf
+class MimeTypeTest < ActiveSupport::TestCase
+  Mime::Type.register "image/png", :png unless defined? Mime::PNG
+  Mime::Type.register "application/pdf", :pdf unless defined? Mime::PDF
 
-  def test_parse_single
+  test "parse single" do
     Mime::LOOKUP.keys.each do |mime_type|
       assert_equal [Mime::Type.lookup(mime_type)], Mime::Type.parse(mime_type)
     end
   end
 
-  def test_parse_without_q
+  test "parse without q" do
     accept = "text/xml,application/xhtml+xml,text/yaml,application/xml,text/html,image/png,text/plain,application/pdf,*/*"
     expect = [Mime::HTML, Mime::XML, Mime::YAML, Mime::PNG, Mime::TEXT, Mime::PDF, Mime::ALL]
     assert_equal expect, Mime::Type.parse(accept)
   end
 
-  def test_parse_with_q
+  test "parse with q" do
     accept = "text/xml,application/xhtml+xml,text/yaml; q=0.3,application/xml,text/html; q=0.8,image/png,text/plain; q=0.5,application/pdf,*/*; q=0.2"
     expect = [Mime::HTML, Mime::XML, Mime::PNG, Mime::PDF, Mime::TEXT, Mime::YAML, Mime::ALL]
     assert_equal expect, Mime::Type.parse(accept)
   end
-  
+
   # Accept header send with user HTTP_USER_AGENT: Sunrise/0.42j (Windows XP)
-  def test_parse_crappy_broken_acceptlines
+  test "parse crappy broken acceptlines" do
     accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/*,,*/*;q=0.5"
     expect = [Mime::HTML, Mime::XML, "image/*", Mime::TEXT, Mime::ALL]
     assert_equal expect, Mime::Type.parse(accept).collect { |c| c.to_s }
   end
 
-  # Accept header send with user HTTP_USER_AGENT: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1)
-  def test_parse_crappy_broken_acceptlines2
+  # Accept header send with user HTTP_USER_AGENT: Mozilla/4.0
+  #  (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1)
+  test "parse crappy broken acceptlines2" do
     accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword,  , pronto/1.00.00, sslvpn/1.00.00.00, */*"
     expect = ['image/gif', 'image/x-xbitmap', 'image/jpeg','image/pjpeg', 'application/x-shockwave-flash', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint', 'application/msword', 'pronto/1.00.00', 'sslvpn/1.00.00.00', Mime::ALL  ]
     assert_equal expect, Mime::Type.parse(accept).collect { |c| c.to_s }
   end
-  
-  def test_custom_type
-    Mime::Type.register("image/gif", :gif)
-    assert_nothing_raised do 
-      Mime::GIF
-      assert_equal Mime::GIF, Mime::SET.last
+
+  test "custom type" do
+    begin
+      Mime::Type.register("image/gif", :gif)
+      assert_nothing_raised do
+        Mime::GIF
+        assert_equal Mime::GIF, Mime::SET.last
+      end
+    ensure
+      Mime.module_eval { remove_const :GIF if const_defined?(:GIF) }
     end
-  ensure
-    Mime.module_eval { remove_const :GIF if const_defined?(:GIF) }
   end
-  
-  def test_type_should_be_equal_to_symbol
+
+  test "type should be equal to symbol" do
     assert_equal Mime::HTML, 'application/xhtml+xml'
     assert_equal Mime::HTML, :html
   end
 
-  def test_type_convenience_methods
+  test "type convenience methods" do
     # Don't test Mime::ALL, since it Mime::ALL#html? == true
     types = Mime::SET.to_a.map(&:to_sym).uniq - [:all]
 
@@ -67,12 +70,12 @@ class MimeTypeTest < Test::Unit::TestCase
     end
   end
 
-  def test_mime_all_is_html
+  test "mime all is html" do
     assert Mime::ALL.all?,  "Mime::ALL is not all?"
     assert Mime::ALL.html?, "Mime::ALL is not html?"
   end
 
-  def test_verifiable_mime_types
+  test "verifiable mime types" do
     all_types = Mime::SET.to_a.map(&:to_sym)
     all_types.uniq!
     # Remove custom Mime::Type instances set in other tests, like Mime::GIF and Mime::IPHONE
@@ -82,7 +85,7 @@ class MimeTypeTest < Test::Unit::TestCase
     assert unverified.each { |type| assert !Mime.const_get(type.to_s.upcase).verify_request?, "Nonverifiable Mime Type is verified: #{type.inspect}" }
   end
 
-  def test_regexp_matcher
+  test "regexp matcher" do
     assert Mime::JS =~ "text/javascript"
     assert Mime::JS =~ "application/javascript"
     assert Mime::JS !~ "text/html"
diff --git a/actionpack/test/controller/rack_test.rb b/actionpack/test/dispatch/rack_test.rb
index 89bf4fdacc..9fad4b22ee 100644
--- a/actionpack/test/controller/rack_test.rb
+++ b/actionpack/test/dispatch/rack_test.rb
@@ -1,6 +1,8 @@
 require 'abstract_unit'
 
-class BaseRackTest < Test::Unit::TestCase
+# TODO: Merge these tests into RequestTest
+
+class BaseRackTest < ActiveSupport::TestCase
   def setup
     @env = {
       "HTTP_MAX_FORWARDS" => "10",
@@ -43,30 +45,27 @@ class BaseRackTest < Test::Unit::TestCase
       "REDIRECT_STATUS" => "200",
       "REQUEST_METHOD" => "GET"
     }
-    @request = ActionController::Request.new(@env)
+    @request = ActionDispatch::Request.new(@env)
     # some Nokia phone browsers omit the space after the semicolon separator.
     # some developers have grown accustomed to using comma in cookie values.
-    @alt_cookie_fmt_request = ActionController::Request.new(@env.merge({"HTTP_COOKIE"=>"_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes"}))
+    @alt_cookie_fmt_request = ActionDispatch::Request.new(@env.merge({"HTTP_COOKIE"=>"_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes"}))
   end
 
-  def default_test; end
-
   private
-
-  def set_content_data(data)
-    @request.env['REQUEST_METHOD'] = 'POST'
-    @request.env['CONTENT_LENGTH'] = data.length
-    @request.env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8'
-    @request.env['rack.input'] = StringIO.new(data)
-  end
+    def set_content_data(data)
+      @request.env['REQUEST_METHOD'] = 'POST'
+      @request.env['CONTENT_LENGTH'] = data.length
+      @request.env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8'
+      @request.env['rack.input'] = StringIO.new(data)
+    end
 end
 
 class RackRequestTest < BaseRackTest
-  def test_proxy_request
+  test "proxy request" do
     assert_equal 'glu.ttono.us', @request.host_with_port
   end
 
-  def test_http_host
+  test "http host" do
     @env.delete "HTTP_X_FORWARDED_HOST"
     @env['HTTP_HOST'] = "rubyonrails.org:8080"
     assert_equal "rubyonrails.org", @request.host
@@ -76,19 +75,19 @@ class RackRequestTest < BaseRackTest
     assert_equal "www.secondhost.org", @request.host
   end
 
-  def test_http_host_with_default_port_overrides_server_port
+  test "http host with default port overrides server port" do
     @env.delete "HTTP_X_FORWARDED_HOST"
     @env['HTTP_HOST'] = "rubyonrails.org"
     assert_equal "rubyonrails.org", @request.host_with_port
   end
 
-  def test_host_with_port_defaults_to_server_name_if_no_host_headers
+  test "host with port defaults to server name if no host headers" do
     @env.delete "HTTP_X_FORWARDED_HOST"
     @env.delete "HTTP_HOST"
     assert_equal "glu.ttono.us:8007", @request.host_with_port
   end
 
-  def test_host_with_port_falls_back_to_server_addr_if_necessary
+  test "host with port falls back to server addr if necessary" do
     @env.delete "HTTP_X_FORWARDED_HOST"
     @env.delete "HTTP_HOST"
     @env.delete "SERVER_NAME"
@@ -97,30 +96,30 @@ class RackRequestTest < BaseRackTest
     assert_equal "207.7.108.53:8007", @request.host_with_port
   end
 
-  def test_host_with_port_if_http_standard_port_is_specified
+  test "host with port if http standard port is specified" do
     @env['HTTP_X_FORWARDED_HOST'] = "glu.ttono.us:80"
     assert_equal "glu.ttono.us", @request.host_with_port
   end
 
-  def test_host_with_port_if_https_standard_port_is_specified
+  test "host with port if https standard port is specified" do
     @env['HTTP_X_FORWARDED_PROTO'] = "https"
     @env['HTTP_X_FORWARDED_HOST'] = "glu.ttono.us:443"
     assert_equal "glu.ttono.us", @request.host_with_port
   end
 
-  def test_host_if_ipv6_reference
+  test "host if ipv6 reference" do
     @env.delete "HTTP_X_FORWARDED_HOST"
     @env['HTTP_HOST'] = "[2001:1234:5678:9abc:def0::dead:beef]"
     assert_equal "[2001:1234:5678:9abc:def0::dead:beef]", @request.host
   end
 
-  def test_host_if_ipv6_reference_with_port
+  test "host if ipv6 reference with port" do
     @env.delete "HTTP_X_FORWARDED_HOST"
     @env['HTTP_HOST'] = "[2001:1234:5678:9abc:def0::dead:beef]:8008"
     assert_equal "[2001:1234:5678:9abc:def0::dead:beef]", @request.host
   end
 
-  def test_cgi_environment_variables
+  test "cgi environment variables" do
     assert_equal "Basic", @request.auth_type
     assert_equal 0, @request.content_length
     assert_equal nil, @request.content_type
@@ -151,7 +150,7 @@ class RackRequestTest < BaseRackTest
     assert_equal "lighttpd", @request.server_software
   end
 
-  def test_cookie_syntax_resilience
+  test "cookie syntax resilience" do
     cookies = @request.cookies
     assert_equal "c84ace84796670c052c6ceb2451fb0f2", cookies["_session_id"], cookies.inspect
     assert_equal "yes", cookies["is_admin"], cookies.inspect
@@ -163,39 +162,39 @@ class RackRequestTest < BaseRackTest
 end
 
 class RackRequestParamsParsingTest < BaseRackTest
-  def test_doesnt_break_when_content_type_has_charset
+  test "doesnt break when content type has charset" do
     set_content_data 'flamenco=love'
 
     assert_equal({"flamenco"=> "love"}, @request.request_parameters)
   end
 
-  def test_doesnt_interpret_request_uri_as_query_string_when_missing
+  test "doesnt interpret request uri as query string when missing" do
     @request.env['REQUEST_URI'] = 'foo'
     assert_equal({}, @request.query_parameters)
   end
 end
 
 class RackRequestContentTypeTest < BaseRackTest
-  def test_html_content_type_verification
+  test "html content type verification" do
     @request.env['CONTENT_TYPE'] = Mime::HTML.to_s
     assert @request.content_type.verify_request?
   end
 
-  def test_xml_content_type_verification
+  test "xml content type verification" do
     @request.env['CONTENT_TYPE'] = Mime::XML.to_s
     assert !@request.content_type.verify_request?
   end
 end
 
 class RackRequestNeedsRewoundTest < BaseRackTest
-  def test_body_should_be_rewound
+  test "body should be rewound" do
     data = 'foo'
     @env['rack.input'] = StringIO.new(data)
     @env['CONTENT_LENGTH'] = data.length
     @env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8'
 
     # Read the request body by parsing params.
-    request = ActionController::Request.new(@env)
+    request = ActionDispatch::Request.new(@env)
     request.request_parameters
 
     # Should have rewound the body.
@@ -206,10 +205,10 @@ end
 class RackResponseTest < BaseRackTest
   def setup
     super
-    @response = ActionController::Response.new
+    @response = ActionDispatch::Response.new
   end
 
-  def test_simple_output
+  test "simple output" do
     @response.body = "Hello, World!"
     @response.prepare!
 
@@ -266,11 +265,11 @@ end
 class RackResponseHeadersTest < BaseRackTest
   def setup
     super
-    @response = ActionController::Response.new
+    @response = ActionDispatch::Response.new
     @response.status = "200 OK"
   end
 
-  def test_content_type
+  test "content type" do
     [204, 304].each do |c|
       @response.status = c.to_s
       assert !response_headers.has_key?("Content-Type"), "#{c} should not have Content-Type header"
@@ -282,7 +281,7 @@ class RackResponseHeadersTest < BaseRackTest
     end
   end
 
-  def test_status
+  test "status" do
     assert !response_headers.has_key?('Status')
   end
 
diff --git a/actionpack/test/controller/request/json_params_parsing_test.rb b/actionpack/test/dispatch/request/json_params_parsing_test.rb
index a3dde72c4e..a3dde72c4e 100644
--- a/actionpack/test/controller/request/json_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/json_params_parsing_test.rb
diff --git a/actionpack/test/controller/request/multipart_params_parsing_test.rb b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
index b812072ef4..88b81dc493 100644
--- a/actionpack/test/controller/request/multipart_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
@@ -206,8 +206,8 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
       end
 
       def call(env)
-        req = Rack::Request.new(env)
-        req.params # Parse params
+        env['rack.input'].read
+        env['rack.input'].rewind
         @app.call(env)
       end
     end
@@ -215,7 +215,7 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
     def with_muck_middleware
       original_middleware = ActionController::Dispatcher.middleware
       middleware = original_middleware.dup
-      middleware.insert_after ActionController::RewindableInput, MuckMiddleware
+      middleware.insert_after ActionDispatch::RewindableInput, MuckMiddleware
       ActionController::Dispatcher.middleware = middleware
       yield
       ActionController::Dispatcher.middleware = original_middleware
diff --git a/actionpack/test/controller/request/query_string_parsing_test.rb b/actionpack/test/dispatch/request/query_string_parsing_test.rb
index a31e326ddf..a31e326ddf 100644
--- a/actionpack/test/controller/request/query_string_parsing_test.rb
+++ b/actionpack/test/dispatch/request/query_string_parsing_test.rb
diff --git a/actionpack/test/controller/request/url_encoded_params_parsing_test.rb b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
index 7e6099a041..8de4a83d76 100644
--- a/actionpack/test/controller/request/url_encoded_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
@@ -150,8 +150,8 @@ class UrlEncodedParamsParsingTest < ActionController::IntegrationTest
       end
 
       def call(env)
-        req = Rack::Request.new(env)
-        req.params # Parse params
+        env['rack.input'].read
+        env['rack.input'].rewind
         @app.call(env)
       end
     end
@@ -159,7 +159,7 @@ class UrlEncodedParamsParsingTest < ActionController::IntegrationTest
     def with_muck_middleware
       original_middleware = ActionController::Dispatcher.middleware
       middleware = original_middleware.dup
-      middleware.insert_after ActionController::RewindableInput, MuckMiddleware
+      middleware.insert_after ActionDispatch::RewindableInput, MuckMiddleware
       ActionController::Dispatcher.middleware = middleware
       yield
       ActionController::Dispatcher.middleware = original_middleware
diff --git a/actionpack/test/controller/request/xml_params_parsing_test.rb b/actionpack/test/dispatch/request/xml_params_parsing_test.rb
index ee764e726e..ee764e726e 100644
--- a/actionpack/test/controller/request/xml_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/xml_params_parsing_test.rb
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
new file mode 100644
index 0000000000..d57a2a611f
--- /dev/null
+++ b/actionpack/test/dispatch/request_test.rb
@@ -0,0 +1,405 @@
+require 'abstract_unit'
+
+class RequestTest < ActiveSupport::TestCase
+  def setup
+    ActionController::Base.relative_url_root = nil
+  end
+
+  def teardown
+    ActionController::Base.relative_url_root = nil
+  end
+
+  test "remote ip" do
+    request = stub_request 'REMOTE_ADDR' => '1.2.3.4'
+    assert_equal '1.2.3.4', request.remote_ip
+
+    request = stub_request 'REMOTE_ADDR' => '1.2.3.4,3.4.5.6'
+    assert_equal '1.2.3.4', request.remote_ip
+
+    request = stub_request 'REMOTE_ADDR' => '1.2.3.4',
+      'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
+    assert_equal '1.2.3.4', request.remote_ip
+
+    request = stub_request 'REMOTE_ADDR' => '127.0.0.1',
+      'HTTP_X_FORWARDED_FOR' => '3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => 'unknown,3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '172.16.0.1,3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '192.168.0.1,3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '10.0.0.1,3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '10.0.0.1, 10.0.0.1, 3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '127.0.0.1,3.4.5.6'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => 'unknown,192.168.0.1'
+    assert_equal 'unknown', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '9.9.9.9, 3.4.5.6, 10.0.0.1, 172.31.4.4'
+    assert_equal '3.4.5.6', request.remote_ip
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '1.1.1.1',
+                           'HTTP_CLIENT_IP'       => '2.2.2.2'
+    e = assert_raise(ActionController::ActionControllerError) {
+      request.remote_ip
+    }
+    assert_match /IP spoofing attack/, e.message
+    assert_match /HTTP_X_FORWARDED_FOR="1.1.1.1"/, e.message
+    assert_match /HTTP_CLIENT_IP="2.2.2.2"/, e.message
+
+    # turn IP Spoofing detection off.
+    # This is useful for sites that are aimed at non-IP clients.  The typical
+    # example is WAP.  Since the cellular network is not IP based, it's a
+    # leap of faith to assume that their proxies are ever going to set the
+    # HTTP_CLIENT_IP/HTTP_X_FORWARDED_FOR headers properly.
+    ActionController::Base.ip_spoofing_check = false
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '1.1.1.1',
+                           'HTTP_CLIENT_IP'       => '2.2.2.2'
+    assert_equal '2.2.2.2', request.remote_ip
+    ActionController::Base.ip_spoofing_check = true
+
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '8.8.8.8, 9.9.9.9'
+    assert_equal '9.9.9.9', request.remote_ip
+  end
+
+  test "domains" do
+    request = stub_request 'HTTP_HOST' => 'www.rubyonrails.org'
+    assert_equal "rubyonrails.org", request.domain
+
+    request = stub_request 'HTTP_HOST' => "www.rubyonrails.co.uk"
+    assert_equal "rubyonrails.co.uk", request.domain(2)
+
+    request = stub_request 'HTTP_HOST' => "192.168.1.200"
+    assert_nil request.domain
+
+    request = stub_request 'HTTP_HOST' => "foo.192.168.1.200"
+    assert_nil request.domain
+
+    request = stub_request 'HTTP_HOST' => "192.168.1.200.com"
+    assert_equal "200.com", request.domain
+  end
+
+  test "subdomains" do
+    request = stub_request 'HTTP_HOST' => "www.rubyonrails.org"
+    assert_equal %w( www ), request.subdomains
+
+    request = stub_request 'HTTP_HOST' => "www.rubyonrails.co.uk"
+    assert_equal %w( www ), request.subdomains(2)
+
+    request = stub_request 'HTTP_HOST' => "dev.www.rubyonrails.co.uk"
+    assert_equal %w( dev www ), request.subdomains(2)
+
+    request = stub_request 'HTTP_HOST' => "foobar.foobar.com"
+    assert_equal %w( foobar ), request.subdomains
+
+    request = stub_request 'HTTP_HOST' => "192.168.1.200"
+    assert_equal [], request.subdomains
+
+    request = stub_request 'HTTP_HOST' => "foo.192.168.1.200"
+    assert_equal [], request.subdomains
+
+    request = stub_request 'HTTP_HOST' => "192.168.1.200.com"
+    assert_equal %w( 192 168 1 ), request.subdomains
+
+    request = stub_request 'HTTP_HOST' => nil
+    assert_equal [], request.subdomains
+  end
+
+  test "port string" do
+    request = stub_request 'HTTP_HOST' => 'www.example.org:80'
+    assert_equal "", request.port_string
+
+    request = stub_request 'HTTP_HOST' => 'www.example.org:8080'
+    assert_equal ":8080", request.port_string
+  end
+
+  test "request uri" do
+    request = stub_request 'REQUEST_URI' => "http://www.rubyonrails.org/path/of/some/uri?mapped=1"
+    assert_equal "/path/of/some/uri?mapped=1", request.request_uri
+    assert_equal "/path/of/some/uri",          request.path
+
+    request = stub_request 'REQUEST_URI' => "http://www.rubyonrails.org/path/of/some/uri"
+    assert_equal "/path/of/some/uri", request.request_uri
+    assert_equal "/path/of/some/uri", request.path
+
+    request = stub_request 'REQUEST_URI' => "/path/of/some/uri"
+    assert_equal "/path/of/some/uri", request.request_uri
+    assert_equal "/path/of/some/uri", request.path
+
+    request = stub_request 'REQUEST_URI' => "/"
+    assert_equal "/", request.request_uri
+    assert_equal "/", request.path
+
+    request = stub_request 'REQUEST_URI' => "/?m=b"
+    assert_equal "/?m=b", request.request_uri
+    assert_equal "/",     request.path
+
+    request = stub_request 'REQUEST_URI' => "/", 'SCRIPT_NAME' => '/dispatch.cgi'
+    assert_equal "/", request.request_uri
+    assert_equal "/", request.path
+
+    ActionController::Base.relative_url_root = "/hieraki"
+    request = stub_request 'REQUEST_URI' => "/hieraki/", 'SCRIPT_NAME' => "/hieraki/dispatch.cgi"
+    assert_equal "/hieraki/", request.request_uri
+    assert_equal "/",         request.path
+    ActionController::Base.relative_url_root = nil
+
+    ActionController::Base.relative_url_root = "/collaboration/hieraki"
+    request = stub_request 'REQUEST_URI' => "/collaboration/hieraki/books/edit/2",
+      'SCRIPT_NAME' => "/collaboration/hieraki/dispatch.cgi"
+    assert_equal "/collaboration/hieraki/books/edit/2", request.request_uri
+    assert_equal "/books/edit/2",                       request.path
+    ActionController::Base.relative_url_root = nil
+
+    # The following tests are for when REQUEST_URI is not supplied (as in IIS)
+    request = stub_request 'PATH_INFO'   => "/path/of/some/uri?mapped=1",
+                           'SCRIPT_NAME' => nil,
+                           'REQUEST_URI' => nil
+    assert_equal "/path/of/some/uri?mapped=1", request.request_uri
+    assert_equal "/path/of/some/uri",          request.path
+
+    ActionController::Base.relative_url_root = '/path'
+    request = stub_request 'PATH_INFO'   => "/path/of/some/uri?mapped=1",
+                           'SCRIPT_NAME' => "/path/dispatch.rb",
+                           'REQUEST_URI' => nil
+    assert_equal "/path/of/some/uri?mapped=1", request.request_uri
+    assert_equal "/of/some/uri",               request.path
+    ActionController::Base.relative_url_root = nil
+
+    request = stub_request 'PATH_INFO'   => "/path/of/some/uri",
+                           'SCRIPT_NAME' => nil,
+                           'REQUEST_URI' => nil
+    assert_equal "/path/of/some/uri", request.request_uri
+    assert_equal "/path/of/some/uri", request.path
+
+    request = stub_request 'PATH_INFO' => '/', 'REQUEST_URI' => nil
+    assert_equal "/", request.request_uri
+    assert_equal "/", request.path
+
+    request = stub_request 'PATH_INFO' => '/?m=b', 'REQUEST_URI' => nil
+    assert_equal "/?m=b", request.request_uri
+    assert_equal "/",     request.path
+
+    request = stub_request 'PATH_INFO'   => "/",
+                           'SCRIPT_NAME' => "/dispatch.cgi",
+                           'REQUEST_URI' => nil
+    assert_equal "/", request.request_uri
+    assert_equal "/", request.path
+
+    ActionController::Base.relative_url_root = '/hieraki'
+    request = stub_request 'PATH_INFO'   => "/hieraki/",
+                           'SCRIPT_NAME' => "/hieraki/dispatch.cgi",
+                           'REQUEST_URI' => nil
+    assert_equal "/hieraki/", request.request_uri
+    assert_equal "/",         request.path
+    ActionController::Base.relative_url_root = nil
+
+    request = stub_request 'REQUEST_URI' => '/hieraki/dispatch.cgi'
+    ActionController::Base.relative_url_root = '/hieraki'
+    assert_equal "/dispatch.cgi", request.path
+    ActionController::Base.relative_url_root = nil
+
+    request = stub_request 'REQUEST_URI' => '/hieraki/dispatch.cgi'
+    ActionController::Base.relative_url_root = '/foo'
+    assert_equal "/hieraki/dispatch.cgi", request.path
+    ActionController::Base.relative_url_root = nil
+
+    # This test ensures that Rails uses REQUEST_URI over PATH_INFO
+    ActionController::Base.relative_url_root = nil
+    request = stub_request 'REQUEST_URI' => "/some/path",
+                           'PATH_INFO'   => "/another/path",
+                           'SCRIPT_NAME' => "/dispatch.cgi"
+    assert_equal "/some/path", request.request_uri
+    assert_equal "/some/path", request.path
+  end
+
+
+  test "host with default port" do
+    request = stub_request 'HTTP_HOST' => 'rubyonrails.org:80'
+    assert_equal "rubyonrails.org", request.host_with_port
+  end
+
+  test "host with non default port" do
+    request = stub_request 'HTTP_HOST' => 'rubyonrails.org:81'
+    assert_equal "rubyonrails.org:81", request.host_with_port
+  end
+
+  test "server software" do
+    request = stub_request
+    assert_equal nil, request.server_software
+
+    request = stub_request 'SERVER_SOFTWARE' => 'Apache3.422'
+    assert_equal 'apache', request.server_software
+
+    request = stub_request 'SERVER_SOFTWARE' => 'lighttpd(1.1.4)'
+    assert_equal 'lighttpd', request.server_software
+  end
+
+  test "xml http request" do
+    request = stub_request
+
+    assert !request.xml_http_request?
+    assert !request.xhr?
+
+    request = stub_request 'HTTP_X_REQUESTED_WITH' => 'DefinitelyNotAjax1.0'
+    assert !request.xml_http_request?
+    assert !request.xhr?
+
+    request = stub_request 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'
+    assert request.xml_http_request?
+    assert request.xhr?
+  end
+
+  test "reports ssl" do
+    request = stub_request
+    assert !request.ssl?
+
+    request = stub_request 'HTTPS' => 'on'
+    assert request.ssl?
+  end
+
+  test "reports ssl when proxied via lighttpd" do
+    request = stub_request
+    assert !request.ssl?
+
+    request = stub_request 'HTTP_X_FORWARDED_PROTO' => 'https'
+    assert request.ssl?
+  end
+
+  test "symbolized request methods" do
+    [:get, :post, :put, :delete].each do |method|
+      request = stub_request 'REQUEST_METHOD' => method.to_s.upcase
+      assert_equal method, request.method
+    end
+  end
+
+  test "invalid http method raises exception" do
+    assert_raise(ActionController::UnknownHttpMethod) do
+      request = stub_request 'REQUEST_METHOD' => 'RANDOM_METHOD'
+      request.request_method
+    end
+  end
+
+  test "allow method hacking on post" do
+    [:get, :head, :options, :put, :post, :delete].each do |method|
+      request = stub_request "REQUEST_METHOD" => method.to_s.upcase
+      assert_equal(method == :head ? :get : method, request.method)
+    end
+  end
+
+  test "invalid method hacking on post raises exception" do
+    assert_raise(ActionController::UnknownHttpMethod) do
+      request = stub_request "REQUEST_METHOD" => "_RANDOM_METHOD"
+      request.request_method
+    end
+  end
+
+  test "restrict method hacking" do
+    [:get, :put, :delete].each do |method|
+      request = stub_request 'REQUEST_METHOD' => method.to_s.upcase,
+        'action_controller.request.request_parameters' => { :_method => 'put' }
+      assert_equal method, request.method
+    end
+  end
+
+  test "head masquerading as get" do
+    request = stub_request 'REQUEST_METHOD' => 'HEAD'
+    assert_equal :get, request.method
+    assert request.get?
+    assert request.head?
+  end
+
+  test "xml format" do
+    request = stub_request
+    request.expects(:parameters).at_least_once.returns({ :format => 'xml' })
+    assert_equal Mime::XML, request.format
+  end
+
+  test "xhtml format" do
+    request = stub_request
+    request.expects(:parameters).at_least_once.returns({ :format => 'xhtml' })
+    assert_equal Mime::HTML, request.format
+  end
+
+  test "txt format" do
+    request = stub_request
+    request.expects(:parameters).at_least_once.returns({ :format => 'txt' })
+    assert_equal Mime::TEXT, request.format
+  end
+
+  test "XMLHttpRequest" do
+    begin
+      ActionController::Base.use_accept_header, old =
+        false, ActionController::Base.use_accept_header
+
+      request = stub_request 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'
+      request.expects(:parameters).at_least_once.returns({})
+      assert request.xhr?
+      assert_equal Mime::JS, request.format
+    ensure
+      ActionController::Base.use_accept_header = old
+    end
+  end
+
+  test "content type" do
+    request = stub_request 'CONTENT_TYPE' => 'text/html'
+    assert_equal Mime::HTML, request.content_type
+  end
+
+  test "can override format with parameter" do
+    request = stub_request
+    request.expects(:parameters).at_least_once.returns({ :format => :txt })
+    assert !request.format.xml?
+
+    request = stub_request
+    request.expects(:parameters).at_least_once.returns({ :format => :xml })
+    assert request.format.xml?
+  end
+
+  test "no content type" do
+    request = stub_request
+    assert_equal nil, request.content_type
+  end
+
+  test "content type is XML" do
+    request = stub_request 'CONTENT_TYPE' => 'application/xml'
+    assert_equal Mime::XML, request.content_type
+  end
+
+  test "content type with charset" do
+    request = stub_request 'CONTENT_TYPE' => 'application/xml; charset=UTF-8'
+    assert_equal Mime::XML, request.content_type
+  end
+
+  test "user agent" do
+    request = stub_request 'HTTP_USER_AGENT' => 'TestAgent'
+    assert_equal 'TestAgent', request.user_agent
+  end
+
+  test "parameters" do
+    request = stub_request
+    request.stubs(:request_parameters).returns({ "foo" => 1 })
+    request.stubs(:query_parameters).returns({ "bar" => 2 })
+
+    assert_equal({"foo" => 1, "bar" => 2}, request.parameters)
+    assert_equal({"foo" => 1}, request.request_parameters)
+    assert_equal({"bar" => 2}, request.query_parameters)
+  end
+
+protected
+
+  def stub_request(env={})
+    ActionDispatch::Request.new(env)
+  end
+
+end
diff --git a/actionpack/test/controller/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index 48a961ca34..b9bf8cf411 100644
--- a/actionpack/test/controller/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -6,7 +6,8 @@ class CookieStoreTest < ActionController::IntegrationTest
   SessionSecret = 'b3c631c314c0bbca50c1b2843150fe33'
 
   DispatcherApp = ActionController::Dispatcher.new
-  CookieStoreApp = ActionController::Session::CookieStore.new(DispatcherApp, :key => SessionKey, :secret => SessionSecret)
+  CookieStoreApp = ActionDispatch::Session::CookieStore.new(DispatcherApp,
+                     :key => SessionKey, :secret => SessionSecret)
 
   Verifier = ActiveSupport::MessageVerifier.new(SessionSecret, 'SHA1')
 
@@ -53,41 +54,41 @@ class CookieStoreTest < ActionController::IntegrationTest
 
   def test_raises_argument_error_if_missing_session_key
     assert_raise(ArgumentError, nil.inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
         :key => nil, :secret => SessionSecret)
     }
 
     assert_raise(ArgumentError, ''.inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
         :key => '', :secret => SessionSecret)
     }
   end
 
   def test_raises_argument_error_if_missing_secret
     assert_raise(ArgumentError, nil.inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
        :key => SessionKey, :secret => nil)
     }
 
     assert_raise(ArgumentError, ''.inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
        :key => SessionKey, :secret => '')
     }
   end
 
   def test_raises_argument_error_if_secret_is_probably_insecure
     assert_raise(ArgumentError, "password".inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
        :key => SessionKey, :secret => "password")
     }
 
     assert_raise(ArgumentError, "secret".inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
        :key => SessionKey, :secret => "secret")
     }
 
     assert_raise(ArgumentError, "12345678901234567890123456789".inspect) {
-      ActionController::Session::CookieStore.new(nil,
+      ActionDispatch::Session::CookieStore.new(nil,
        :key => SessionKey, :secret => "12345678901234567890123456789")
     }
   end
@@ -135,7 +136,7 @@ class CookieStoreTest < ActionController::IntegrationTest
 
   def test_close_raises_when_data_overflows
     with_test_route_set do
-      assert_raise(ActionController::Session::CookieStore::CookieOverflow) {
+      assert_raise(ActionDispatch::Session::CookieStore::CookieOverflow) {
         get '/raise_data_overflow'
       }
     end
@@ -194,23 +195,35 @@ class CookieStoreTest < ActionController::IntegrationTest
   end
 
   def test_session_store_with_expire_after
-    app = ActionController::Session::CookieStore.new(DispatcherApp, :key => SessionKey, :secret => SessionSecret, :expire_after => 5.hours)
+    app = ActionDispatch::Session::CookieStore.new(DispatcherApp, :key => SessionKey, :secret => SessionSecret, :expire_after => 5.hours)
     @integration_session = open_session(app)
 
     with_test_route_set do
       # First request accesses the session
+      time = Time.local(2008, 4, 24)
+      Time.stubs(:now).returns(time)
+      expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+
       cookies[SessionKey] = SignedBar
 
       get '/set_session_value'
       assert_response :success
-      cookie = headers['Set-Cookie']
 
-      # Second request does not access the session so the
-      # expires header should not be changed
+      cookie_body = response.body
+      assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly",
+        headers['Set-Cookie']
+
+      # Second request does not access the session
+      time = Time.local(2008, 4, 25)
+      Time.stubs(:now).returns(time)
+      expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d-%b-%Y %H:%M:%S GMT")
+
       get '/no_session_access'
       assert_response :success
-      assert_equal cookie, headers['Set-Cookie'],
-        "#{unmarshal_session(cookie).inspect} expected but was #{unmarshal_session(headers['Set-Cookie']).inspect}"
+
+      # Mystery bug that came up in 2.3 as well. What is this trying to test?!
+      # assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly",
+      #   headers['Set-Cookie']
     end
   end
 
diff --git a/actionpack/test/controller/session/mem_cache_store_test.rb b/actionpack/test/dispatch/session/mem_cache_store_test.rb
index 2f80a3c7c2..7561c93e4a 100644
--- a/actionpack/test/controller/session/mem_cache_store_test.rb
+++ b/actionpack/test/dispatch/session/mem_cache_store_test.rb
@@ -33,7 +33,7 @@ class MemCacheStoreTest < ActionController::IntegrationTest
 
   begin
     DispatcherApp = ActionController::Dispatcher.new
-    MemCacheStoreApp = ActionController::Session::MemCacheStore.new(
+    MemCacheStoreApp = ActionDispatch::Session::MemCacheStore.new(
                          DispatcherApp, :key => '_session_id')
 
 
diff --git a/actionpack/test/controller/session/test_session_test.rb b/actionpack/test/dispatch/session/test_session_test.rb
index de6539e1cc..de6539e1cc 100644
--- a/actionpack/test/controller/session/test_session_test.rb
+++ b/actionpack/test/dispatch/session/test_session_test.rb
diff --git a/actionpack/test/fixtures/happy_path/render_action/hello_world.erb b/actionpack/test/fixtures/happy_path/render_action/hello_world.erb
new file mode 100644
index 0000000000..6769dd60bd
--- /dev/null
+++ b/actionpack/test/fixtures/happy_path/render_action/hello_world.erb
@@ -0,0 +1 @@
+Hello world!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/views/goodbye.rhtml b/actionpack/test/fixtures/layout_tests/views/goodbye.rhtml
new file mode 100644
index 0000000000..bbccf0913e
--- /dev/null
+++ b/actionpack/test/fixtures/layout_tests/views/goodbye.rhtml
@@ -0,0 +1 @@
+hello.rhtml
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layouts/default_html.html.erb b/actionpack/test/fixtures/layouts/default_html.html.erb
deleted file mode 100644
index edd719111c..0000000000
--- a/actionpack/test/fixtures/layouts/default_html.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<html><%= @content_for_layout %></html>
diff --git a/actionpack/test/fixtures/test/basic.html.erb b/actionpack/test/fixtures/test/basic.html.erb
new file mode 100644
index 0000000000..ea696d7e01
--- /dev/null
+++ b/actionpack/test/fixtures/test/basic.html.erb
@@ -0,0 +1 @@
+Hello from basic.html.erb
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/render_implicit_js_template_without_layout.js.erb b/actionpack/test/fixtures/test/render_implicit_js_template_without_layout.js.erb
deleted file mode 100644
index d5b94af505..0000000000
--- a/actionpack/test/fixtures/test/render_implicit_js_template_without_layout.js.erb
+++ /dev/null
@@ -1 +0,0 @@
-alert('hello');
diff --git a/actionpack/test/lib/fixture_template.rb b/actionpack/test/lib/fixture_template.rb
new file mode 100644
index 0000000000..26f6ec2d0c
--- /dev/null
+++ b/actionpack/test/lib/fixture_template.rb
@@ -0,0 +1,35 @@
+module ActionView #:nodoc:
+  class FixtureTemplate < Template
+    class FixturePath < Template::Path
+      def initialize(hash = {})
+        @hash = {}
+        
+        hash.each do |k, v|
+          @hash[k.sub(/\.\w+$/, '')] = FixtureTemplate.new(v, k.split("/").last, self)
+        end
+        
+        super("fixtures://root")
+      end
+      
+      def find_template(path)
+        @hash[path]
+      end
+    end
+    
+    def initialize(body, *args)
+      @body = body
+      super(*args)
+    end
+    
+    def source
+      @body
+    end
+  
+  private
+  
+    def find_full_path(path, load_paths)
+      return '/', path
+    end
+  
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/base_test.rb b/actionpack/test/new_base/base_test.rb
new file mode 100644
index 0000000000..4f46cb6492
--- /dev/null
+++ b/actionpack/test/new_base/base_test.rb
@@ -0,0 +1,90 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+# Tests the controller dispatching happy path
+module HappyPath
+  class SimpleDispatchController < ActionController::Base2
+    def index
+      render :text => "success"
+    end
+
+    def modify_response_body
+      self.response_body = "success"
+    end
+    
+    def modify_response_body_twice
+      ret = (self.response_body = "success") 
+      self.response_body = "#{ret}!"
+    end
+    
+    def modify_response_headers
+      
+    end
+  end
+  
+  class TestSimpleDispatch < SimpleRouteCase
+    
+    get "/happy_path/simple_dispatch/index"
+        
+    test "sets the body" do
+      assert_body "success"
+    end
+    
+    test "sets the status code" do
+      assert_status 200
+    end
+    
+    test "sets the content type" do
+      assert_content_type Mime::HTML
+    end
+    
+    test "sets the content length" do
+      assert_header "Content-Length", 7
+    end
+        
+  end
+  
+  # :api: plugin
+  class TestDirectResponseMod < SimpleRouteCase
+    get "/happy_path/simple_dispatch/modify_response_body"
+        
+    test "sets the body" do
+      assert_body "success"
+    end
+    
+    test "setting the body manually sets the content length" do
+      assert_header "Content-Length", 7
+    end
+  end
+  
+  # :api: plugin
+  class TestDirectResponseModTwice < SimpleRouteCase
+    get "/happy_path/simple_dispatch/modify_response_body_twice"
+    
+    test "self.response_body= returns the body being set" do
+      assert_body "success!"
+    end
+    
+    test "updating the response body updates the content length" do
+      assert_header "Content-Length", 8
+    end
+  end
+end
+
+
+class EmptyController < ActionController::Base2 ; end
+module Submodule
+  class ContainedEmptyController < ActionController::Base2 ; end
+end
+
+class ControllerClassTests < Test::Unit::TestCase
+  def test_controller_path
+    assert_equal 'empty', EmptyController.controller_path
+    assert_equal EmptyController.controller_path, EmptyController.new.controller_path
+    assert_equal 'submodule/contained_empty', Submodule::ContainedEmptyController.controller_path
+    assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
+  end
+  def test_controller_name
+    assert_equal 'empty', EmptyController.controller_name
+    assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
+ end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_action_test.rb b/actionpack/test/new_base/render_action_test.rb
new file mode 100644
index 0000000000..2bfb374a31
--- /dev/null
+++ b/actionpack/test/new_base/render_action_test.rb
@@ -0,0 +1,325 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module RenderAction
+  
+  # This has no layout and it works
+  class BasicController < ActionController::Base2
+    
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "render_action/basic/hello_world.html.erb" => "Hello world!"
+    )]
+    
+    def hello_world
+      render :action => "hello_world"
+    end
+    
+    def hello_world_as_string
+      render "hello_world"
+    end
+    
+    def hello_world_as_string_with_options
+      render "hello_world", :status => 404
+    end
+    
+    def hello_world_as_symbol
+      render :hello_world
+    end
+
+    def hello_world_with_symbol
+      render :action => :hello_world
+    end
+    
+    def hello_world_with_layout
+      render :action => "hello_world", :layout => true
+    end
+    
+    def hello_world_with_layout_false
+      render :action => "hello_world", :layout => false
+    end
+    
+    def hello_world_with_layout_nil
+      render :action => "hello_world", :layout => nil
+    end
+    
+    def hello_world_with_custom_layout
+      render :action => "hello_world", :layout => "greetings"
+    end
+    
+  end
+  
+  class TestBasic < SimpleRouteCase
+    describe "Rendering an action using :action => <String>"
+    
+    get "/render_action/basic/hello_world"
+    assert_body   "Hello world!"
+    assert_status 200
+  end
+  
+  class TestWithString < SimpleRouteCase
+    describe "Render an action using 'hello_world'"
+    
+    get "/render_action/basic/hello_world_as_string"
+    assert_body   "Hello world!"
+    assert_status 200
+  end
+  
+  class TestWithStringAndOptions < SimpleRouteCase
+    describe "Render an action using 'hello_world'"
+    
+    get "/render_action/basic/hello_world_as_string_with_options"
+    assert_body   "Hello world!"
+    assert_status 404
+  end
+  
+  class TestAsSymbol < SimpleRouteCase
+    describe "Render an action using :hello_world"
+    
+    get "/render_action/basic/hello_world_as_symbol"
+    assert_body   "Hello world!"
+    assert_status 200
+  end
+  
+  class TestWithSymbol < SimpleRouteCase
+    describe "Render an action using :action => :hello_world"
+    
+    get "/render_action/basic/hello_world_with_symbol"
+    assert_body   "Hello world!"
+    assert_status 200
+  end
+  
+  class TestLayoutTrue < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => true"
+    
+    test "raises an exception when requesting a layout and none exist" do
+      assert_raise(ArgumentError, /no default layout for RenderAction::BasicController in/) do 
+        get "/render_action/basic/hello_world_with_layout"
+      end
+    end
+  end
+  
+  class TestLayoutFalse < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => false"
+    
+    get "/render_action/basic/hello_world_with_layout_false"
+    assert_body   "Hello world!"
+    assert_status 200
+  end
+  
+  class TestLayoutNil < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :nil"
+    
+    get "/render_action/basic/hello_world_with_layout_nil"
+    assert_body   "Hello world!"
+    assert_status 200
+  end
+  
+  class TestCustomLayout < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => 'greetings'"
+    
+    test "raises an exception when requesting a layout that does not exist" do
+      assert_raise(ActionView::MissingTemplate) { get "/render_action/basic/hello_world_with_custom_layout" }
+    end
+  end
+  
+end
+
+module RenderActionWithApplicationLayout
+  
+  # # ==== Render actions with layouts ====
+
+  class BasicController < ::ApplicationController
+    # Set the view path to an application view structure with layouts
+    self.view_paths = self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "render_action_with_application_layout/basic/hello_world.html.erb" => "Hello World!",
+      "layouts/application.html.erb"                                     => "OHAI <%= yield %> KTHXBAI",
+      "layouts/greetings.html.erb"                                       => "Greetings <%= yield %> Bai"
+    )]
+    
+    def hello_world
+      render :action => "hello_world"
+    end
+    
+    def hello_world_with_layout
+      render :action => "hello_world", :layout => true
+    end
+    
+    def hello_world_with_layout_false
+      render :action => "hello_world", :layout => false
+    end
+    
+    def hello_world_with_layout_nil
+      render :action => "hello_world", :layout => nil
+    end
+    
+    def hello_world_with_custom_layout
+      render :action => "hello_world", :layout => "greetings"
+    end
+  end
+  
+  class TestDefaultLayout < SimpleRouteCase
+    describe %(
+      Render hello_world and implicitly use application.html.erb as a layout if 
+      no layout is specified and no controller layout is present
+    )
+      
+    get "/render_action_with_application_layout/basic/hello_world"
+    assert_body   "OHAI Hello World! KTHXBAI"
+    assert_status 200
+  end
+  
+  class TestLayoutTrue < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => true"
+    
+    get "/render_action_with_application_layout/basic/hello_world_with_layout"
+    assert_body   "OHAI Hello World! KTHXBAI"
+    assert_status 200
+  end
+  
+  class TestLayoutFalse < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => false"
+    
+    get "/render_action_with_application_layout/basic/hello_world_with_layout_false"
+    assert_body   "Hello World!"
+    assert_status 200
+  end
+  
+  class TestLayoutNil < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :nil"
+    
+    get "/render_action_with_application_layout/basic/hello_world_with_layout_nil"
+    assert_body   "Hello World!"
+    assert_status 200
+  end
+  
+  class TestCustomLayout < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => 'greetings'"
+    
+    get "/render_action_with_application_layout/basic/hello_world_with_custom_layout"
+    assert_body   "Greetings Hello World! Bai"
+    assert_status 200
+  end
+  
+end
+
+module RenderActionWithControllerLayout
+  
+  class BasicController < ActionController::Base2
+    self.view_paths = self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "render_action_with_controller_layout/basic/hello_world.html.erb" => "Hello World!",
+      "layouts/render_action_with_controller_layout/basic.html.erb"     => "With Controller Layout! <%= yield %> KTHXBAI"
+    )]
+    
+    def hello_world
+      render :action => "hello_world"
+    end
+    
+    def hello_world_with_layout
+      render :action => "hello_world", :layout => true
+    end
+    
+    def hello_world_with_layout_false
+      render :action => "hello_world", :layout => false
+    end
+    
+    def hello_world_with_layout_nil
+      render :action => "hello_world", :layout => nil
+    end
+    
+    def hello_world_with_custom_layout
+      render :action => "hello_world", :layout => "greetings"
+    end
+  end
+  
+  class TestControllerLayout < SimpleRouteCase
+    describe "Render hello_world and implicitly use <controller_path>.html.erb as a layout."
+
+    get "/render_action_with_controller_layout/basic/hello_world"
+    assert_body   "With Controller Layout! Hello World! KTHXBAI"
+    assert_status 200
+  end
+  
+  class TestLayoutTrue < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => true"
+    
+    get "/render_action_with_controller_layout/basic/hello_world_with_layout"
+    assert_body   "With Controller Layout! Hello World! KTHXBAI"
+    assert_status 200
+  end
+  
+  class TestLayoutFalse < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => false"
+    
+    get "/render_action_with_controller_layout/basic/hello_world_with_layout_false"
+    assert_body   "Hello World!"
+    assert_status 200
+  end
+  
+  class TestLayoutNil < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :nil"
+    
+    get "/render_action_with_controller_layout/basic/hello_world_with_layout_nil"
+    assert_body   "Hello World!"
+    assert_status 200
+  end
+  
+end
+
+module RenderActionWithBothLayouts
+  
+  class BasicController < ActionController::Base2
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new({
+      "render_action_with_both_layouts/basic/hello_world.html.erb" => "Hello World!",
+      "layouts/application.html.erb"                                => "OHAI <%= yield %> KTHXBAI",
+      "layouts/render_action_with_both_layouts/basic.html.erb"      => "With Controller Layout! <%= yield %> KTHXBAI"
+    })]
+    
+    def hello_world
+      render :action => "hello_world"
+    end
+    
+    def hello_world_with_layout
+      render :action => "hello_world", :layout => true
+    end
+    
+    def hello_world_with_layout_false
+      render :action => "hello_world", :layout => false
+    end
+    
+    def hello_world_with_layout_nil
+      render :action => "hello_world", :layout => nil
+    end
+  end
+  
+  class TestControllerLayoutFirst < SimpleRouteCase
+    describe "Render hello_world and implicitly use <controller_path>.html.erb over application.html.erb as a layout"
+
+    get "/render_action_with_both_layouts/basic/hello_world"
+    assert_body   "With Controller Layout! Hello World! KTHXBAI"
+    assert_status 200
+  end
+  
+  class TestLayoutTrue < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => true"
+    
+    get "/render_action_with_both_layouts/basic/hello_world_with_layout"
+    assert_body   "With Controller Layout! Hello World! KTHXBAI"
+    assert_status 200
+  end
+  
+  class TestLayoutFalse < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => false"
+    
+    get "/render_action_with_both_layouts/basic/hello_world_with_layout_false"
+    assert_body   "Hello World!"
+    assert_status 200
+  end
+  
+  class TestLayoutNil < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :nil"
+    
+    get "/render_action_with_both_layouts/basic/hello_world_with_layout_nil"
+    assert_body   "Hello World!"
+    assert_status 200
+  end
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_implicit_action_test.rb b/actionpack/test/new_base/render_implicit_action_test.rb
new file mode 100644
index 0000000000..798505b539
--- /dev/null
+++ b/actionpack/test/new_base/render_implicit_action_test.rb
@@ -0,0 +1,16 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module HappyPath
+  
+  class RenderImplicitActionController < ActionController::Base2
+    # No actions yet, they are implicit
+  end
+  
+  class TestRendersActionImplicitly < SimpleRouteCase
+  
+    test "renders action implicitly" do
+      assert true
+    end
+  
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_layout_test.rb b/actionpack/test/new_base/render_layout_test.rb
new file mode 100644
index 0000000000..facf67ea85
--- /dev/null
+++ b/actionpack/test/new_base/render_layout_test.rb
@@ -0,0 +1,45 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module ControllerLayouts
+  class ImplicitController < ::ApplicationController
+    
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "layouts/application.html.erb" => "OMG <%= yield %> KTHXBAI",
+      "basic.html.erb" => "Hello world!"
+    )]
+    
+    def index
+      render :template => "basic"
+    end
+  end
+  
+  class TestImplicitLayout < SimpleRouteCase
+    describe "rendering a normal template, but using the implicit layout"
+    
+    get "/controller_layouts/implicit/index"
+    assert_body   "OMG Hello world! KTHXBAI"
+    assert_status 200
+  end
+  
+  class ImplicitNameController < ::ApplicationController
+    
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "layouts/controller_layouts/implicit_name.html.erb" => "OMGIMPLICIT <%= yield %> KTHXBAI",
+      "basic.html.erb" => "Hello world!"
+    )]
+        
+    def index
+      render :template => "basic"
+    end
+  end
+  
+  class TestImplicitNamedLayout < SimpleRouteCase
+    describe "rendering a normal template, but using an implicit NAMED layout"
+    
+    get "/controller_layouts/implicit_name/index"
+    assert_body   "OMGIMPLICIT Hello world! KTHXBAI"
+    assert_status 200
+  end
+  
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_template_test.rb b/actionpack/test/new_base/render_template_test.rb
new file mode 100644
index 0000000000..c6c0269b40
--- /dev/null
+++ b/actionpack/test/new_base/render_template_test.rb
@@ -0,0 +1,133 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module HappyPath
+  
+  class RenderTemplateWithoutLayoutController < ActionController::Base2
+    
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "test/basic.html.erb" => "Hello from basic.html.erb",
+      "shared.html.erb"     => "Elastica"
+    )]
+    
+    def render_hello_world
+      render :template => "test/basic"
+    end
+
+    def render_hello_world_with_forward_slash
+      render :template => "/test/basic"
+    end
+
+    def render_template_in_top_directory
+      render :template => 'shared'
+    end
+
+    def render_template_in_top_directory_with_slash
+      render :template => '/shared'
+    end
+  end
+  
+  class TestTemplateRenderWithoutLayout < SimpleRouteCase
+    describe "rendering a normal template with full path without layout"
+    
+    get "/happy_path/render_template_without_layout/render_hello_world"
+    assert_body   "Hello from basic.html.erb"
+    assert_status 200
+  end
+  
+  class TestTemplateRenderWithForwardSlash < SimpleRouteCase
+    describe "rendering a normal template with full path starting with a leading slash"
+    
+    get "/happy_path/render_template_without_layout/render_hello_world_with_forward_slash"
+    assert_body   "Hello from basic.html.erb"
+    assert_status 200
+  end
+  
+  class TestTemplateRenderInTopDirectory < SimpleRouteCase
+    describe "rendering a template not in a subdirectory"
+    
+    get "/happy_path/render_template_without_layout/render_template_in_top_directory"
+    assert_body   "Elastica"
+    assert_status 200
+  end
+
+  class TestTemplateRenderInTopDirectoryWithSlash < SimpleRouteCase
+    describe "rendering a template not in a subdirectory with a leading slash"
+    
+    get "/happy_path/render_template_without_layout/render_template_in_top_directory_with_slash"
+    assert_body   "Elastica"
+    assert_status 200
+  end
+    
+  class RenderTemplateWithLayoutController < ::ApplicationController
+    
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "test/basic.html.erb"          => "Hello from basic.html.erb",
+      "shared.html.erb"              => "Elastica",
+      "layouts/application.html.erb" => "<%= yield %>, I'm here!",
+      "layouts/greetings.html.erb"   => "<%= yield %>, I wish thee well."
+    )]
+    
+    def render_hello_world
+      render :template => "test/basic"
+    end
+    
+    def render_hello_world_with_layout
+      render :template => "test/basic", :layout => true
+    end
+    
+    def render_hello_world_with_layout_false
+      render :template => "test/basic", :layout => false
+    end
+    
+    def render_hello_world_with_layout_nil
+      render :template => "test/basic", :layout => nil
+    end
+    
+    def render_hello_world_with_custom_layout
+      render :template => "test/basic", :layout => "greetings"
+    end
+  end
+  
+  class TestTemplateRenderWithLayout < SimpleRouteCase
+    describe "rendering a normal template with full path with layout"
+    
+    get "/happy_path/render_template_with_layout/render_hello_world"
+    assert_body   "Hello from basic.html.erb, I'm here!"
+    assert_status 200
+  end
+  
+  class TestTemplateRenderWithLayoutTrue < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :true"
+    
+    get "/happy_path/render_template_with_layout/render_hello_world_with_layout"
+    assert_body   "Hello from basic.html.erb, I'm here!"
+    assert_status 200
+  end
+  
+  class TestTemplateRenderWithLayoutFalse < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :false"
+    
+    get "/happy_path/render_template_with_layout/render_hello_world_with_layout_false"
+    assert_body   "Hello from basic.html.erb"
+    assert_status 200
+  end
+  
+  class TestTemplateRenderWithLayoutNil < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => :nil"
+    
+    get "/happy_path/render_template_with_layout/render_hello_world_with_layout_nil"
+    assert_body   "Hello from basic.html.erb"
+    assert_status 200
+  end
+  
+  class TestTemplateRenderWithCustomLayout < SimpleRouteCase
+    describe "rendering a normal template with full path with layout => 'greetings'"
+    
+    get "/happy_path/render_template_with_layout/render_hello_world_with_custom_layout"
+    assert_body   "Hello from basic.html.erb, I wish thee well."
+    assert_status 200
+  end
+  
+  
+
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_text_test.rb b/actionpack/test/new_base/render_text_test.rb
new file mode 100644
index 0000000000..a20ca5fb8c
--- /dev/null
+++ b/actionpack/test/new_base/render_text_test.rb
@@ -0,0 +1,144 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+class ApplicationController < ActionController::Base2
+end
+
+module HappyPath
+  
+  class RenderTextWithoutLayoutsController < ActionController::Base2
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new]
+    
+    def render_hello_world
+      render :text => "hello david"
+    end
+  end
+  
+  class RenderTextWithLayoutsController < ::ApplicationController
+    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      "layouts/application.html.erb" => "<%= yield %>, I'm here!",
+      "layouts/greetings.html.erb"   => "<%= yield %>, I wish thee well."
+    )]    
+    
+    def render_hello_world
+      render :text => "hello david"
+    end
+    
+    def render_custom_code
+      render :text => "hello world", :status => 404
+    end
+    
+    def render_with_custom_code_as_string
+      render :text => "hello world", :status => "404 Not Found"
+    end
+    
+    def render_text_with_nil
+      render :text => nil
+    end
+    
+    def render_text_with_nil_and_status
+      render :text => nil, :status => 403
+    end
+
+    def render_text_with_false
+      render :text => false
+    end
+    
+    def render_text_with_layout
+      render :text => "hello world", :layout => true
+    end
+    
+    def render_text_with_layout_false
+      render :text => "hello world", :layout => false
+    end
+    
+    def render_text_with_layout_nil
+      render :text => "hello world", :layout => nil
+    end
+    
+    def render_text_with_custom_layout
+      render :text => "hello world", :layout => "greetings"
+    end
+  end
+  
+  class TestSimpleTextRenderWithNoLayout < SimpleRouteCase
+    describe "Rendering text from a action with default options renders the text with the layout"
+    
+    get "/happy_path/render_text_without_layouts/render_hello_world"
+    assert_body   "hello david"
+    assert_status 200
+  end
+  
+  class TestSimpleTextRenderWithLayout < SimpleRouteCase    
+    describe "Rendering text from a action with default options renders the text without the layout"
+    
+    get "/happy_path/render_text_with_layouts/render_hello_world"
+    assert_body   "hello david"
+    assert_status 200
+  end
+  
+  class TestTextRenderWithStatus < SimpleRouteCase
+    describe "Rendering text, while also providing a custom status code"
+    
+    get "/happy_path/render_text_with_layouts/render_custom_code"
+    assert_body   "hello world"
+    assert_status 404
+  end
+  
+  class TestTextRenderWithNil < SimpleRouteCase
+    describe "Rendering text with nil returns a single space character"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_nil"
+    assert_body   " "
+    assert_status 200
+  end
+  
+  class TestTextRenderWithNilAndStatus < SimpleRouteCase
+    describe "Rendering text with nil and custom status code returns a single space character with the status"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_nil_and_status"
+    assert_body   " "
+    assert_status 403
+  end
+  
+  class TestTextRenderWithFalse < SimpleRouteCase
+    describe "Rendering text with false returns the string 'false'"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_false"
+    assert_body   "false"
+    assert_status 200
+  end
+  
+  class TestTextRenderWithLayoutTrue < SimpleRouteCase
+    describe "Rendering text with :layout => true"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_layout"
+    assert_body "hello world, I'm here!"
+    assert_status 200
+  end
+  
+  class TestTextRenderWithCustomLayout < SimpleRouteCase
+    describe "Rendering text with :layout => 'greetings'"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_custom_layout"
+    assert_body "hello world, I wish thee well."
+    assert_status 200
+  end
+  
+  class TestTextRenderWithLayoutFalse < SimpleRouteCase
+    describe "Rendering text with :layout => false"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_layout_false"
+    assert_body "hello world"
+    assert_status 200
+  end
+  
+  class TestTextRenderWithLayoutNil < SimpleRouteCase
+    describe "Rendering text with :layout => nil"
+    
+    get "/happy_path/render_text_with_layouts/render_text_with_layout_nil"
+    assert_body "hello world"
+    assert_status 200
+  end
+end
+
+ActionController::Base2.app_loaded!
\ No newline at end of file
diff --git a/actionpack/test/new_base/test_helper.rb b/actionpack/test/new_base/test_helper.rb
new file mode 100644
index 0000000000..d29449ddc1
--- /dev/null
+++ b/actionpack/test/new_base/test_helper.rb
@@ -0,0 +1,144 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'action_controller'
+require 'action_view/base'
+require 'fixture_template'
+
+begin
+  require 'ruby-debug'
+  Debugger.settings[:autoeval] = true
+  Debugger.start
+rescue LoadError
+  # Debugging disabled. `gem install ruby-debug` to enable.
+end
+
+require 'action_controller/abstract'
+require 'action_controller/new_base'
+require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
+
+require 'rubygems'
+require 'rack/test'
+
+module ActionController
+  class Base2 < AbstractBase
+    use AbstractController::Callbacks
+    use AbstractController::Helpers
+    use AbstractController::Logger
+
+    use ActionController::HideActions
+    use ActionController::UrlFor
+    use ActionController::Renderer
+    use ActionController::Layouts
+    
+    def self.inherited(klass)
+      ::ActionController::Base2.subclasses << klass.to_s
+      super
+    end
+    
+    def self.subclasses
+      @subclasses ||= []
+    end
+    
+    def self.app_loaded!
+      @subclasses.each do |subclass|
+        subclass.constantize._write_layout_method
+      end
+    end
+    
+    # append_view_path File.join(File.dirname(__FILE__), '..', 'fixtures')
+        
+    CORE_METHODS = self.public_instance_methods
+  end
+end
+
+# Temporary base class
+class Rack::TestCase < ActiveSupport::TestCase
+  include Rack::Test::Methods
+  
+  setup do
+    ActionController::Base.session_options[:key] = "abc"
+    ActionController::Base.session_options[:secret] = ("*" * 30)
+    
+    controllers = ActionController::Base2.subclasses.map do |k| 
+      k.underscore.sub(/_controller$/, '')
+    end
+    
+    ActionController::Routing.use_controllers!(controllers)
+    
+    # Move into a bootloader
+    AbstractController::Base.subclasses.each do |klass|
+      klass = klass.constantize
+      next unless klass < AbstractController::Layouts
+      klass.class_eval do
+        _write_layout_method
+      end
+    end    
+  end
+    
+  def app
+    @app ||= ActionController::Dispatcher.new
+  end
+  
+  def self.get(url)
+    setup do |test|
+      test.get url
+    end
+  end
+  
+  def assert_body(body)
+    assert_equal [body], last_response.body
+  end
+  
+  def self.assert_body(body)
+    test "body is set to '#{body}'" do
+      assert_body body
+    end
+  end
+  
+  def assert_status(code)
+    assert_equal code, last_response.status
+  end
+  
+  def self.assert_status(code)
+    test "status code is set to #{code}" do
+      assert_status code
+    end
+  end
+  
+  def assert_content_type(type)
+    assert_equal type, last_response.headers["Content-Type"]
+  end
+  
+  def self.assert_content_type(type)
+    test "content type is set to #{type}" do
+      assert_content_type(type)
+    end
+  end
+  
+  def assert_header(name, value)
+    assert_equal value, last_response.headers[name]
+  end
+  
+  def self.assert_header(name, value)
+    test "'#{name}' header is set to #{value.inspect}" do
+      assert_header(name, value)
+    end
+  end
+  
+end
+
+class ::ApplicationController < ActionController::Base2
+end
+
+class SimpleRouteCase < Rack::TestCase
+  setup do
+    ActionController::Routing::Routes.draw do |map|
+      map.connect ':controller/:action/:id'
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/runner b/actionpack/test/runner
new file mode 100755
index 0000000000..c2bbe63c75
--- /dev/null
+++ b/actionpack/test/runner
@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+
+ARGV.each do |arg|
+  Dir["#{Dir.pwd}/#{arg}/**/*_test.rb"].each do |file|
+    require file
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/template/active_record_helper_i18n_test.rb b/actionpack/test/template/active_record_helper_i18n_test.rb
index 4b6e8ddcca..9d04c882c8 100644
--- a/actionpack/test/template/active_record_helper_i18n_test.rb
+++ b/actionpack/test/template/active_record_helper_i18n_test.rb
@@ -4,9 +4,12 @@ class ActiveRecordHelperI18nTest < Test::Unit::TestCase
   include ActionView::Helpers::ActiveRecordHelper
   
   attr_reader :request
+
   def setup
     @object = stub :errors => stub(:count => 1, :full_messages => ['full_messages'])
-    @object_name = 'book'
+    @object_name = 'book_seller'
+    @object_name_without_underscore = 'book seller'
+
     stubs(:content_tag).returns 'content_tag'
 
     I18n.stubs(:t).with(:'header', :locale => 'en', :scope => [:activerecord, :errors, :template], :count => 1, :model => '').returns "1 error prohibited this  from being saved"
@@ -37,8 +40,8 @@ class ActiveRecordHelperI18nTest < Test::Unit::TestCase
   end
   
   def test_error_messages_for_given_object_name_it_translates_object_name
-    I18n.expects(:t).with(:header, :locale => 'en', :scope => [:activerecord, :errors, :template], :count => 1, :model => @object_name).returns "1 error prohibited this #{@object_name} from being saved"
-    I18n.expects(:t).with(@object_name, :default => @object_name, :count => 1, :scope => [:activerecord, :models]).once.returns @object_name
+    I18n.expects(:t).with(:header, :locale => 'en', :scope => [:activerecord, :errors, :template], :count => 1, :model => @object_name_without_underscore).returns "1 error prohibited this #{@object_name_without_underscore} from being saved"
+    I18n.expects(:t).with(@object_name, :default => @object_name_without_underscore, :count => 1, :scope => [:activerecord, :models]).once.returns @object_name_without_underscore
     error_messages_for(:object => @object, :locale => 'en', :object_name => @object_name)
   end
 end
diff --git a/actionpack/test/template/active_record_helper_test.rb b/actionpack/test/template/active_record_helper_test.rb
index 83c028b5f2..b4b8cbe074 100644
--- a/actionpack/test/template/active_record_helper_test.rb
+++ b/actionpack/test/template/active_record_helper_test.rb
@@ -112,6 +112,7 @@ class ActiveRecordHelperTest < ActionView::TestCase
   attr_accessor :request_forgery_protection_token, :form_authenticity_token
 
   def setup
+    super
     setup_post
     setup_user
 
diff --git a/actionpack/test/template/asset_tag_helper_test.rb b/actionpack/test/template/asset_tag_helper_test.rb
index 32ad87c12d..76ceff8d6c 100644
--- a/actionpack/test/template/asset_tag_helper_test.rb
+++ b/actionpack/test/template/asset_tag_helper_test.rb
@@ -4,6 +4,7 @@ class AssetTagHelperTest < ActionView::TestCase
   tests ActionView::Helpers::AssetTagHelper
 
   def setup
+    super
     silence_warnings do
       ActionView::Helpers::AssetTagHelper.send(
         :const_set,
@@ -627,6 +628,7 @@ class AssetTagHelperNonVhostTest < ActionView::TestCase
   tests ActionView::Helpers::AssetTagHelper
 
   def setup
+    super
     ActionController::Base.relative_url_root = "/collaboration/hieraki"
 
     @controller = Class.new do
diff --git a/actionpack/test/template/atom_feed_helper_test.rb b/actionpack/test/template/atom_feed_helper_test.rb
index 8a00a397ca..bd97caf5d7 100644
--- a/actionpack/test/template/atom_feed_helper_test.rb
+++ b/actionpack/test/template/atom_feed_helper_test.rb
@@ -170,6 +170,7 @@ class AtomFeedTest < ActionController::TestCase
   tests ScrollsController
 
   def setup
+    super
     @request.host = "www.nextangle.com"
   end
 
diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb
index 7d1d7634a8..c75e29ed9a 100644
--- a/actionpack/test/template/compiled_templates_test.rb
+++ b/actionpack/test/template/compiled_templates_test.rb
@@ -2,7 +2,6 @@ require 'abstract_unit'
 require 'controller/fake_models'
 
 class CompiledTemplatesTest < Test::Unit::TestCase
-  
   def setup
     @compiled_templates = ActionView::Base::CompiledTemplates
     @compiled_templates.instance_methods.each do |m|
@@ -11,193 +10,76 @@ class CompiledTemplatesTest < Test::Unit::TestCase
   end
 
   def test_template_gets_compiled
-    with_caching(true) do
-      assert_equal 0, @compiled_templates.instance_methods.size
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      assert_equal 1, @compiled_templates.instance_methods.size
-    end
+    assert_equal 0, @compiled_templates.instance_methods.size
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
+    assert_equal 1, @compiled_templates.instance_methods.size
   end
 
   def test_template_gets_recompiled_when_using_different_keys_in_local_assigns
-    with_caching(true) do
-      assert_equal 0, @compiled_templates.instance_methods.size
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb", :locals => {:foo => "bar"})
-      assert_equal 2, @compiled_templates.instance_methods.size
-    end
+    assert_equal 0, @compiled_templates.instance_methods.size
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb", :locals => {:foo => "bar"})
+    assert_equal 2, @compiled_templates.instance_methods.size
   end
 
   def test_compiled_template_will_not_be_recompiled_when_rendered_with_identical_local_assigns
-    with_caching(true) do
-      assert_equal 0, @compiled_templates.instance_methods.size
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      ActionView::Template.any_instance.expects(:compile!).never
-      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-    end
-  end
-
-  def test_template_changes_are_not_reflected_with_cached_template_loading
-    with_caching(true) do
-      with_reloading(false) do
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-        modify_template "test/hello_world.erb", "Goodbye world!" do
-          assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-        end
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      end
-    end
-  end
-
-  def test_template_changes_are_reflected_without_cached_template_loading
-    with_caching(true) do
-      with_reloading(true) do
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-        modify_template "test/hello_world.erb", "Goodbye world!" do
-          assert_equal "Goodbye world!", render(:file => "test/hello_world.erb")
-        end
-        assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-      end
-    end
+    assert_equal 0, @compiled_templates.instance_methods.size
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
+    ActionView::Template.any_instance.expects(:compile!).never
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
   end
 
-  def test_template_becomes_missing_if_deleted_without_cached_template_loading
-    with_reloading(true) do
-      assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
-      delete_template 'test/hello_world.erb' do
-        assert_raise(ActionView::MissingTemplate) { render(:file => 'test/hello_world.erb') }
-      end
-      assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
-    end
-  end
-
-  def test_swapping_template_handler_is_working_without_cached_template_loading
-    with_reloading(true) do
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      delete_template 'test/hello_world.erb' do
-        rename_template 'test/hello_world_from_rxml.builder', 'test/hello_world.builder' do
-          assert_equal "<html>\n  <p>Hello</p>\n</html>\n", render(:file => 'test/hello_world')
-        end
-      end
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-    end
+  def test_compiled_template_will_always_be_recompiled_when_template_is_not_cached
+    ActionView::Template.any_instance.expects(:recompile?).times(3).returns(true)
+    assert_equal 0, @compiled_templates.instance_methods.size
+    assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb")
+    ActionView::Template.any_instance.expects(:compile!).times(3)
+    3.times { assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb") }
+    assert_equal 1, @compiled_templates.instance_methods.size
   end
 
-  def test_adding_localized_template_will_take_precedence_without_cached_template_loading
-    with_reloading(true) do
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
-        assert_equal 'Hey verden', render(:file => 'test/hello_world')
-      end
+  def test_template_changes_are_not_reflected_with_cached_templates
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
+    modify_template "test/hello_world.erb", "Goodbye world!" do
+      assert_equal "Hello world!", render(:file => "test/hello_world.erb")
     end
+    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
   end
 
-  def test_deleting_localized_template_will_fall_back_to_non_localized_template_without_cached_template_loading
-    with_reloading(true) do
-      rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
-        assert_equal 'Hey verden', render(:file => 'test/hello_world')
-        delete_template 'test/hello_world.en.html.erb' do
-          assert_equal 'Hello world!', render(:file => 'test/hello_world')
-        end
-        assert_equal 'Hey verden', render(:file => 'test/hello_world')
-      end
-    end
-  end
-
-  def test_parallel_reloadable_view_paths_are_working
-    with_reloading(true) do
-      view_paths_copy = new_reloadable_view_paths
-      assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      with_view_paths(view_paths_copy, new_reloadable_view_paths) do
-        assert_equal 'Hello world!', render(:file => 'test/hello_world')
-      end
-      modify_template 'test/hello_world.erb', 'Goodbye world!' do
-        assert_equal 'Goodbye world!', render(:file => 'test/hello_world')
-        modify_template 'test/hello_world.erb', 'So long, world!' do
-          with_view_paths(view_paths_copy, new_reloadable_view_paths) do
-            assert_equal 'So long, world!', render(:file => 'test/hello_world')
-          end
-          assert_equal 'So long, world!', render(:file => 'test/hello_world')
-        end
-      end
+  def test_template_changes_are_reflected_with_uncached_templates
+    assert_equal "Hello world!", render_without_cache(:file => "test/hello_world.erb")
+    modify_template "test/hello_world.erb", "Goodbye world!" do
+      assert_equal "Goodbye world!", render_without_cache(:file => "test/hello_world.erb")
     end
+    assert_equal "Hello world!", render_without_cache(:file => "test/hello_world.erb")
   end
 
   private
     def render(*args)
-      view_paths = @explicit_view_paths || ActionController::Base.view_paths
-      ActionView::Base.new(view_paths, {}).render(*args)
+      render_with_cache(*args)
     end
 
-    def with_view_paths(*args)
-      args.each do |view_paths|
-        begin
-          @explicit_view_paths = view_paths
-          yield
-        ensure
-          @explicit_view_paths = nil
-        end
-      end
+    def render_with_cache(*args)
+      view_paths = ActionController::Base.view_paths
+      assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
+      ActionView::Base.new(view_paths, {}).render(*args)
     end
 
-    def reset_mtime_of(template_name, view_paths_to_use)
-      view_paths_to_use.find_template(template_name).previously_last_modified = 10.seconds.ago unless ActionView::Base.cache_template_loading?
+    def render_without_cache(*args)
+      path = ActionView::Template::FileSystemPath.new(FIXTURE_LOAD_PATH)
+      view_paths = ActionView::Base.process_view_paths(path)
+      assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
+      ActionView::Base.new(view_paths, {}).render(*args)
     end
 
-    def modify_template(template, content, view_paths_to_use = ActionController::Base.view_paths)
-      filename = filename_for(template)
+    def modify_template(template, content)
+      filename = "#{FIXTURE_LOAD_PATH}/#{template}"
       old_content = File.read(filename)
       begin
         File.open(filename, "wb+") { |f| f.write(content) }
-        reset_mtime_of(template, view_paths_to_use)
         yield
       ensure
         File.open(filename, "wb+") { |f| f.write(old_content) }
-        reset_mtime_of(template, view_paths_to_use)
       end
     end
-
-    def filename_for(template)
-      File.join(FIXTURE_LOAD_PATH, template)
-    end
-
-    def rename_template(old_name, new_name)
-      File.rename(filename_for(old_name), filename_for(new_name))
-      yield
-    ensure
-      File.rename(filename_for(new_name), filename_for(old_name))
-    end
-
-    def delete_template(template, &block)
-      rename_template(template, File.join(File.dirname(template), "__#{File.basename(template)}"), &block)
-    end
-
-    def with_caching(perform_caching)
-      old_perform_caching = ActionController::Base.perform_caching
-      begin
-        ActionController::Base.perform_caching = perform_caching
-        yield
-      ensure
-        ActionController::Base.perform_caching = old_perform_caching
-      end
-    end
-
-    def with_reloading(reload_templates, view_paths_owner = ActionController::Base)
-      old_view_paths, old_cache_templates = view_paths_owner.view_paths, ActionView::Base.cache_template_loading
-      begin
-        ActionView::Base.cache_template_loading = !reload_templates
-        view_paths_owner.view_paths = view_paths_for(reload_templates)
-        yield
-      ensure
-        view_paths_owner.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates
-      end
-    end
-
-    def new_reloadable_view_paths
-      ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s))
-    end
-
-    def view_paths_for(reload_templates)
-      # reloadable paths are cheap to create
-      reload_templates ? new_reloadable_view_paths : CACHED_VIEW_PATHS
-    end
 end
diff --git a/actionpack/test/template/form_helper_test.rb b/actionpack/test/template/form_helper_test.rb
index 654eee40a3..104649deac 100644
--- a/actionpack/test/template/form_helper_test.rb
+++ b/actionpack/test/template/form_helper_test.rb
@@ -45,6 +45,7 @@ class FormHelperTest < ActionView::TestCase
   tests ActionView::Helpers::FormHelper
 
   def setup
+    super
     @post = Post.new
     @comment = Comment.new
     def @post.errors()
diff --git a/actionpack/test/template/form_tag_helper_test.rb b/actionpack/test/template/form_tag_helper_test.rb
index c713b8da8e..ea0be4a27a 100644
--- a/actionpack/test/template/form_tag_helper_test.rb
+++ b/actionpack/test/template/form_tag_helper_test.rb
@@ -4,6 +4,7 @@ class FormTagHelperTest < ActionView::TestCase
   tests ActionView::Helpers::FormTagHelper
 
   def setup
+    super
     @controller = Class.new do
       def url_for(options)
         "http://www.example.com"
diff --git a/actionpack/test/template/javascript_helper_test.rb b/actionpack/test/template/javascript_helper_test.rb
index d2fb24e36e..f9bc92c7c9 100644
--- a/actionpack/test/template/javascript_helper_test.rb
+++ b/actionpack/test/template/javascript_helper_test.rb
@@ -3,9 +3,10 @@ require 'abstract_unit'
 class JavaScriptHelperTest < ActionView::TestCase
   tests ActionView::Helpers::JavaScriptHelper
 
-  attr_accessor :template_format, :output_buffer
+  attr_accessor :formats, :output_buffer
 
   def setup
+    super
     @template = self
   end
 
diff --git a/actionpack/test/template/prototype_helper_test.rb b/actionpack/test/template/prototype_helper_test.rb
index d6b86a3964..cd6ee6ea11 100644
--- a/actionpack/test/template/prototype_helper_test.rb
+++ b/actionpack/test/template/prototype_helper_test.rb
@@ -25,9 +25,10 @@ class Author::Nested < Author; end
 
 
 class PrototypeHelperBaseTest < ActionView::TestCase
-  attr_accessor :template_format, :output_buffer
+  attr_accessor :formats, :output_buffer
 
   def setup
+    super
     @template = self
     @controller = Class.new do
       def url_for(options)
diff --git a/actionpack/test/template/record_tag_helper_test.rb b/actionpack/test/template/record_tag_helper_test.rb
index 67aa047745..809ed6d6af 100644
--- a/actionpack/test/template/record_tag_helper_test.rb
+++ b/actionpack/test/template/record_tag_helper_test.rb
@@ -13,6 +13,7 @@ class RecordTagHelperTest < ActionView::TestCase
   tests ActionView::Helpers::RecordTagHelper
 
   def setup
+    super
     @post = Post.new
   end
 
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
index 9adf053b09..8843f6fdd7 100644
--- a/actionpack/test/template/render_test.rb
+++ b/actionpack/test/template/render_test.rb
@@ -29,38 +29,48 @@ module RenderTestCases
   end
 
   def test_render_file_with_localization
-    old_locale = I18n.locale
-    I18n.locale = :da
-    assert_equal "Hey verden", @view.render(:file => "test/hello_world")
-  ensure
-    I18n.locale = old_locale
+    pending do
+      begin
+        old_locale = I18n.locale
+        I18n.locale = :da
+        assert_equal "Hey verden", @view.render(:file => "test/hello_world")
+      ensure
+        I18n.locale = old_locale
+      end
+    end
   end
 
   def test_render_file_with_dashed_locale
     old_locale = I18n.locale
-    I18n.locale = :"pt-BR"
-    assert_equal "Ola mundo", @view.render(:file => "test/hello_world")
+    pending do
+      I18n.locale = :"pt-BR"
+      assert_equal "Ola mundo", @view.render(:file => "test/hello_world")
+    end
   ensure
     I18n.locale = old_locale
   end
 
   def test_render_implicit_html_template_from_xhr_request
-    old_format = @view.template_format
-    @view.template_format = :js
-    assert_equal "Hello HTML!", @view.render(:file => "test/render_implicit_html_template_from_xhr_request")
+    old_format = @view.formats
+    pending do
+      @view.formats = [:js]
+      assert_equal "Hello HTML!", @view.render(:file => "test/render_implicit_html_template_from_xhr_request")
+    end
   ensure
-    @view.template_format = old_format
+    @view.formats = old_format
   end
 
   def test_render_implicit_html_template_from_xhr_request_with_localization
     old_locale = I18n.locale
-    old_format = @view.template_format
-    I18n.locale = :da
-    @view.template_format = :js
-    assert_equal "Hey HTML!\n", @view.render(:file => "test/render_implicit_html_template_from_xhr_request")
+    old_format = @view.formats
+    pending do
+      I18n.locale = :da
+      @view.formats = [:js]
+      assert_equal "Hey HTML!\n", @view.render(:file => "test/render_implicit_html_template_from_xhr_request")
+    end
   ensure
     I18n.locale = old_locale
-    @view.template_format = old_format
+    @view.formats = old_format
   end
 
   def test_render_file_at_top_level
@@ -186,7 +196,7 @@ module RenderTestCases
 
   # TODO: The reason for this test is unclear, improve documentation
   def test_render_missing_xml_partial_and_raise_missing_template
-    @view.template_format = :xml
+    @view.formats = [:xml]
     assert_raise(ActionView::MissingTemplate) { @view.render(:partial => "test/layout_for_partial") }
   end
 
@@ -257,34 +267,26 @@ module RenderTestCases
   end
 end
 
-module TemplatesSetupTeardown
-  def setup_view_paths_for(new_cache_template_loading)
-    @previous_cache_template_loading, ActionView::Base.cache_template_loading = ActionView::Base.cache_template_loading, new_cache_template_loading
-    view_paths = new_cache_template_loading ? CACHED_VIEW_PATHS : ActionView::Base.process_view_paths(CACHED_VIEW_PATHS.map(&:to_s))
-    assert_equal(new_cache_template_loading ? ActionView::Template::EagerPath : ActionView::ReloadableTemplate::ReloadablePath, view_paths.first.class)
-    setup_view(view_paths)
-  end
-  
-  def teardown
-    ActionView::Base.cache_template_loading = @previous_cache_template_loading
-  end
-end
-
-class CachedRenderTest < Test::Unit::TestCase
-  include TemplatesSetupTeardown
+class CachedViewRenderTest < ActiveSupport::TestCase
   include RenderTestCases
 
+  # Ensure view path cache is primed
   def setup
-    setup_view_paths_for(cache_templates = true)
+    view_paths = ActionController::Base.view_paths
+    assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
+    setup_view(view_paths)
   end
 end
 
-class ReloadableRenderTest < Test::Unit::TestCase
-  include TemplatesSetupTeardown
+class LazyViewRenderTest < ActiveSupport::TestCase
   include RenderTestCases
 
+  # Test the same thing as above, but make sure the view path
+  # is not eager loaded
   def setup
-    setup_view_paths_for(cache_templates = false)
+    path = ActionView::Template::FileSystemPath.new(FIXTURE_LOAD_PATH)
+    view_paths = ActionView::Base.process_view_paths(path)
+    assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
+    setup_view(view_paths)
   end
 end
-
diff --git a/actionpack/test/template/scriptaculous_helper_test.rb b/actionpack/test/template/scriptaculous_helper_test.rb
index 690a7751b5..bebc3cb9f4 100644
--- a/actionpack/test/template/scriptaculous_helper_test.rb
+++ b/actionpack/test/template/scriptaculous_helper_test.rb
@@ -4,6 +4,7 @@ class ScriptaculousHelperTest < ActionView::TestCase
   tests ActionView::Helpers::ScriptaculousHelper
 
   def setup
+    super
     @controller = Class.new do
       def url_for(options)
         url =  "http://www.example.com/"
diff --git a/actionpack/test/template/test_test.rb b/actionpack/test/template/test_test.rb
index ccd299f46a..dd07a6d438 100644
--- a/actionpack/test/template/test_test.rb
+++ b/actionpack/test/template/test_test.rb
@@ -20,6 +20,7 @@ end
 
 class PeopleHelperTest < ActionView::TestCase
   def setup
+    super
     ActionController::Routing::Routes.draw do |map|
       map.people 'people', :controller => 'people', :action => 'index'
       map.connect ':controller/:action/:id'
diff --git a/actionpack/test/template/text_helper_test.rb b/actionpack/test/template/text_helper_test.rb
index a370f1458f..be7163888e 100644
--- a/actionpack/test/template/text_helper_test.rb
+++ b/actionpack/test/template/text_helper_test.rb
@@ -6,6 +6,7 @@ class TextHelperTest < ActionView::TestCase
   include TestingSandbox
 
   def setup
+    super
     # This simulates the fact that instance variables are reset every time
     # a view is rendered.  The cycle helper depends on this behavior.
     @_cycles = nil if (defined? @_cycles)
diff --git a/actionpack/test/template/url_helper_test.rb b/actionpack/test/template/url_helper_test.rb
index 5900709d81..f3d2f87b4a 100644
--- a/actionpack/test/template/url_helper_test.rb
+++ b/actionpack/test/template/url_helper_test.rb
@@ -7,6 +7,7 @@ class UrlHelperTest < ActionView::TestCase
   tests ActionView::Helpers::UrlHelper
 
   def setup
+    super
     @controller = Class.new do
       attr_accessor :url, :request
       def url_for(options)
@@ -380,6 +381,7 @@ class UrlHelperWithControllerTest < ActionView::TestCase
   tests ActionView::Helpers::UrlHelper
 
   def setup
+    super
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
     @controller = UrlHelperController.new
@@ -458,6 +460,7 @@ class LinkToUnlessCurrentWithControllerTest < ActionView::TestCase
   tests ActionView::Helpers::UrlHelper
 
   def setup
+    super
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
     @controller = TasksController.new
@@ -560,6 +563,7 @@ class PolymorphicControllerTest < ActionView::TestCase
   tests ActionView::Helpers::UrlHelper
 
   def setup
+    super
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
   end