Merge commit 'mainstream/master'

Conflicts:
	actionpack/lib/action_view/helpers/form_helper.rb

131 files changed, 7183 insertions, 1345 deletions

diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index 426891184a..098dfcf5a2 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -21,16 +21,9 @@
 # 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
-require 'active_support/core/all'
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift activesupport_path if File.directory?(activesupport_path)
+require 'active_support'
 
 require File.join(File.dirname(__FILE__), "action_pack")
 
@@ -60,7 +53,7 @@ module ActionController
   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 :Rescue, 'action_controller/base/rescue'
   autoload :Resources, 'action_controller/routing/resources'
   autoload :Responder, 'action_controller/base/responder'
   autoload :Routing, 'action_controller/routing'
diff --git a/actionpack/lib/action_controller/abstract.rb b/actionpack/lib/action_controller/abstract.rb
index 3f5c4a185f..48e33282ec 100644
--- a/actionpack/lib/action_controller/abstract.rb
+++ b/actionpack/lib/action_controller/abstract.rb
@@ -1,3 +1,6 @@
+require "active_support/core_ext/module/attr_internal"
+require "active_support/core_ext/module/delegation"
+
 module AbstractController
   autoload :Base,           "action_controller/abstract/base"
   autoload :Callbacks,      "action_controller/abstract/callbacks"
diff --git a/actionpack/lib/action_controller/abstract/base.rb b/actionpack/lib/action_controller/abstract/base.rb
index ade7719cc0..f2db201063 100644
--- a/actionpack/lib/action_controller/abstract/base.rb
+++ b/actionpack/lib/action_controller/abstract/base.rb
@@ -1,41 +1,112 @@
+require 'active_support/core_ext/module/attr_internal'
+
 module AbstractController
+  class Error < StandardError; end
+  
+  class DoubleRenderError < Error
+    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 Base
     
     attr_internal :response_body
     attr_internal :response_obj
     attr_internal :action_name
-    
-    def self.process(action)
-      new.process(action)
+
+    class << self
+      attr_reader :abstract    
+      
+      def abstract!
+        @abstract = true
+      end
+      
+      alias_method :abstract?, :abstract
+
+      def inherited(klass)
+        ::AbstractController::Base.subclasses << klass.to_s
+        super
+      end
+
+      def subclasses
+        @subclasses ||= []
+      end
+      
+      def internal_methods
+        controller = self
+        controller = controller.superclass until controller.abstract?
+        controller.public_instance_methods(true)
+      end
+      
+      def process(action)
+        new.process(action.to_s)
+      end
+
+      def hidden_actions
+        []
+      end
+      
+      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
+          internal_methods.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
     
-    def self.inherited(klass)
-    end
+    abstract!
     
     def initialize
       self.response_obj = {}
     end
     
     def process(action_name)
+      action_name = action_name.to_s
+
       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 action_methods
+      self.class.action_methods
+    end
+  
+    def action_method?(action)
+      action_methods.include?(action)
+    end
+  
+    # It is possible for respond_to?(action_name) to be false and
+    # respond_to?(:action_missing) to be false if respond_to_action?
+    # is overridden in a subclass. For instance, ActionController::Base
+    # overrides it to include the case where a template matching the
+    # action_name is found.
     def process_action
-      respond_to?(action_name) ? send(action_name) : send(:action_missing, action_name)
+      if action_method?(action_name) then send(action_name)
+      elsif respond_to?(:action_missing, true) then action_missing(action_name)
+      end
     end
     
+    # Override this to change the conditions that will raise an
+    # ActionNotFound error. If you accept a difference case,
+    # you must handle it by also overriding process_action and
+    # handling the case.
     def respond_to_action?(action_name)
-      respond_to?(action_name) || respond_to?(:action_missing, true)
+      action_method?(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
index c8b509081c..3aff83a209 100644
--- a/actionpack/lib/action_controller/abstract/callbacks.rb
+++ b/actionpack/lib/action_controller/abstract/callbacks.rb
@@ -1,10 +1,13 @@
 module AbstractController
   module Callbacks
-    setup do
-      include ActiveSupport::NewCallbacks
-      define_callbacks :process_action      
+    extend ActiveSupport::DependencyModule
+
+    depends_on ActiveSupport::NewCallbacks
+
+    included do
+      define_callbacks :process_action, "response_body"
     end
-    
+
     def process_action
       _run_process_action_callbacks(action_name) do
         super
@@ -14,11 +17,11 @@ module AbstractController
     module ClassMethods
       def _normalize_callback_options(options)
         if only = options[:only]
-          only = Array(only).map {|o| "action_name == :#{o}"}.join(" || ")
+          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(" || ")          
+          except = Array(except).map {|e| "action_name == '#{e}'"}.join(" || ")          
           options[:per_key] = {:unless => except}
         end
       end
diff --git a/actionpack/lib/action_controller/abstract/helpers.rb b/actionpack/lib/action_controller/abstract/helpers.rb
index 1f0b38417b..968d3080c1 100644
--- a/actionpack/lib/action_controller/abstract/helpers.rb
+++ b/actionpack/lib/action_controller/abstract/helpers.rb
@@ -1,19 +1,14 @@
 module AbstractController
   module Helpers
+    extend ActiveSupport::DependencyModule
+
     depends_on Renderer
-    
-    setup do
+
+    included 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
diff --git a/actionpack/lib/action_controller/abstract/layouts.rb b/actionpack/lib/action_controller/abstract/layouts.rb
index 0039e67c5a..35d5e85ed9 100644
--- a/actionpack/lib/action_controller/abstract/layouts.rb
+++ b/actionpack/lib/action_controller/abstract/layouts.rb
@@ -1,8 +1,9 @@
 module AbstractController
   module Layouts
-    
+    extend ActiveSupport::DependencyModule
+
     depends_on Renderer
-        
+
     module ClassMethods
       def layout(layout)
         unless [String, Symbol, FalseClass, NilClass].include?(layout.class)
@@ -50,13 +51,16 @@ module AbstractController
     end
     
     def _render_template(template, options)
-      _action_view._render_template_with_layout(template, options[:_layout])
+      _action_view._render_template_from_controller(template, options[:_layout], options, options[:_partial])
     end
         
   private
   
     def _layout() end # This will be overwritten
     
+    # :api: plugin
+    # ====
+    # Override this to mutate the inbound layout name
     def _layout_for_name(name)
       unless [String, FalseClass, NilClass].include?(name.class)
         raise ArgumentError, "String, false, or nil expected; you passed #{name.inspect}"
@@ -67,10 +71,10 @@ module AbstractController
     
     def _default_layout(require_layout = false)
       if require_layout && !_layout
-        raise ArgumentError, 
+        raise ArgumentError,
           "There was no default layout for #{self.class} in #{view_paths.inspect}"
       end
-        
+
       begin
         layout = _layout_for_name(_layout)
       rescue NameError => e
diff --git a/actionpack/lib/action_controller/abstract/logger.rb b/actionpack/lib/action_controller/abstract/logger.rb
index 4117369bd4..750a5c9fb6 100644
--- a/actionpack/lib/action_controller/abstract/logger.rb
+++ b/actionpack/lib/action_controller/abstract/logger.rb
@@ -1,7 +1,44 @@
+require 'active_support/core_ext/class/attribute_accessors'
+
 module AbstractController
   module Logger
-    setup do
+    extend ActiveSupport::DependencyModule
+
+    class DelayedLog
+      def initialize(&blk)
+        @blk = blk
+      end
+      
+      def to_s
+        @blk.call
+      end
+      alias to_str to_s
+    end
+
+    included do
       cattr_accessor :logger
     end
+    
+    def process(action)
+      ret = super
+      
+      if logger
+        log = DelayedLog.new do
+          "\n\nProcessing #{self.class.name}\##{action_name} " \
+          "to #{request.formats} " \
+          "(for #{request_origin}) [#{request.method.to_s.upcase}]"
+        end
+
+        logger.info(log)
+      end
+      
+      ret
+    end
+    
+    def request_origin
+      # this *needs* to be cached!
+      # otherwise you'd get different results if calling it more than once
+      @request_origin ||= "#{request.remote_ip} at #{Time.now.to_s(:db)}"
+    end    
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/renderer.rb b/actionpack/lib/action_controller/abstract/renderer.rb
index e31accbbfc..f2044a35ec 100644
--- a/actionpack/lib/action_controller/abstract/renderer.rb
+++ b/actionpack/lib/action_controller/abstract/renderer.rb
@@ -2,22 +2,28 @@ require "action_controller/abstract/logger"
 
 module AbstractController
   module Renderer
+    extend ActiveSupport::DependencyModule
+
     depends_on AbstractController::Logger
-    
-    setup do
+
+    included 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)
+    def render(*args)
+      if response_body
+        raise AbstractController::DoubleRenderError, "OMG"
+      end
+      
+      self.response_body = render_to_body(*args)
     end
     
     # Raw rendering of a template to a Rack-compatible body.
@@ -28,9 +34,16 @@ module AbstractController
     # :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 => formats}, options[:_prefix])
-      _render_template(template, options)
+
+      # TODO: Refactor so we can just use the normal template logic for this
+      if options[:_partial_object]
+        _action_view._render_partial_from_controller(options)
+      else 
+        options[:_template] ||= view_paths.find_by_parts(name.to_s, {:formats => formats}, 
+        options[:_prefix], options[:_partial])
+
+        _render_template(options[:_template], options)
+      end
     end
 
     # Raw rendering of a template to a string.
@@ -44,7 +57,7 @@ module AbstractController
     end
 
     def _render_template(template, options)
-      _action_view._render_template_with_layout(template)
+      _action_view._render_template_from_controller(template, nil, options, options[:_partial])
     end
     
     def view_paths() _view_paths end
diff --git a/actionpack/lib/action_controller/base/base.rb b/actionpack/lib/action_controller/base/base.rb
index 4429b8f0b7..0993b311cd 100644
--- a/actionpack/lib/action_controller/base/base.rb
+++ b/actionpack/lib/action_controller/base/base.rb
@@ -1,5 +1,7 @@
 require 'action_controller/deprecated'
 require 'set'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/module/attr_internal'
 
 module ActionController #:nodoc:
   class ActionControllerError < StandardError #:nodoc:
@@ -30,10 +32,6 @@ module ActionController #:nodoc:
     def allowed_methods_header
       allowed_methods.map { |method_symbol| method_symbol.to_s.upcase } * ', '
     end
-
-    def handle_response!(response)
-      response.headers['Allow'] ||= allowed_methods_header
-    end
   end
 
   class NotImplemented < MethodNotAllowed #:nodoc:
@@ -369,19 +367,23 @@ module ActionController #:nodoc:
 
     attr_reader :template
 
-    class << self
-      def call(env)
-        # HACK: For global rescue to have access to the original request and response
-        request = env["action_controller.rescue.request"] ||= ActionDispatch::Request.new(env)
-        response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
-        process(request, response)
-      end
+    def action(name, env)
+      # HACK: For global rescue to have access to the original request and response
+      request = env["action_controller.rescue.request"] ||= ActionDispatch::Request.new(env)
+      response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
+      self.action_name = name && name.to_s
+      process(request, response).to_a
+    end
 
-      # Factory for the standard create, process loop where the controller is discarded after processing.
-      def process(request, response) #:nodoc:
-        new.process(request, response)
-      end
 
+    class << self
+      def action(name = nil)
+        @actions ||= {}
+        @actions[name] ||= proc do |env|
+          new.action(name, env)
+        end
+      end
+      
       # Converts the class name from something like "OneModule::TwoModule::NeatController" to "NeatController".
       def controller_class_name
         @controller_class_name ||= name.demodulize
@@ -511,6 +513,12 @@ module ActionController #:nodoc:
     end
 
     public
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+        response = ActionDispatch::Response.new
+        process(request, response).to_a
+      end
+
       # Extracts the action_name from the request parameters and performs that action.
       def process(request, response, method = :perform_action, *arguments) #:nodoc:
         response.request = request
@@ -518,7 +526,6 @@ module ActionController #:nodoc:
         assign_shortcuts(request, response)
         initialize_template_class(response)
         initialize_current_url
-        assign_names
 
         log_processing
         send(method, *arguments)
@@ -817,9 +824,9 @@ module ActionController #:nodoc:
       end
 
       def initialize_template_class(response)
-        @template = response.template = ActionView::Base.new(self.class.view_paths, {}, self, formats)
+        @template = ActionView::Base.new(self.class.view_paths, {}, self, formats)
+        response.template = @template if response.respond_to?(:template=)
         @template.helpers.send :include, self.class.master_helper_module
-        response.redirected_to = nil
         @performed_render = @performed_redirect = false
       end
 
@@ -882,10 +889,6 @@ module ActionController #:nodoc:
         @performed_render || @performed_redirect
       end
 
-      def assign_names
-        @action_name = (params['action'] || 'index')
-      end
-
       def reset_variables_added_to_assigns
         @template.instance_variable_set("@assigns_added", nil)
       end
diff --git a/actionpack/lib/action_controller/base/chained/benchmarking.rb b/actionpack/lib/action_controller/base/chained/benchmarking.rb
index 066150f58a..66e9e9c31d 100644
--- a/actionpack/lib/action_controller/base/chained/benchmarking.rb
+++ b/actionpack/lib/action_controller/base/chained/benchmarking.rb
@@ -1,4 +1,4 @@
-require 'benchmark'
+require 'active_support/core_ext/benchmark'
 
 module ActionController #:nodoc:
   # The benchmarking module times the performance of actions and reports to the logger. If the Active Record
diff --git a/actionpack/lib/action_controller/base/http_authentication.rb b/actionpack/lib/action_controller/base/http_authentication.rb
index 9219847cd0..0be53cb02d 100644
--- a/actionpack/lib/action_controller/base/http_authentication.rb
+++ b/actionpack/lib/action_controller/base/http_authentication.rb
@@ -1,3 +1,5 @@
+require 'active_support/base64'
+
 module ActionController
   module HttpAuthentication
     # Makes it dead easy to do HTTP Basic authentication.
@@ -276,7 +278,7 @@ module ActionController
         t = time.to_i
         hashed = [t, secret_key]
         digest = ::Digest::MD5.hexdigest(hashed.join(":"))
-        Base64.encode64("#{t}:#{digest}").gsub("\n", '')
+        ActiveSupport::Base64.encode64("#{t}:#{digest}").gsub("\n", '')
       end
 
       # Might want a shorter timeout depending on whether the request
@@ -285,7 +287,7 @@ module ActionController
       # allow a user to use new nonce without prompting user again for their
       # username and password.
       def validate_nonce(request, value, seconds_to_timeout=5*60)
-        t = Base64.decode64(value).split(":").first.to_i
+        t = ActiveSupport::Base64.decode64(value).split(":").first.to_i
         nonce(t) == value && (t - Time.now.to_i).abs <= seconds_to_timeout
       end
 
diff --git a/actionpack/lib/action_controller/base/layout.rb b/actionpack/lib/action_controller/base/layout.rb
index 1ad5191c73..cf5f46a32b 100644
--- a/actionpack/lib/action_controller/base/layout.rb
+++ b/actionpack/lib/action_controller/base/layout.rb
@@ -1,3 +1,7 @@
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/class/delegating_attributes'
+require 'active_support/core_ext/class/inheritable_attributes'
+
 module ActionController #:nodoc:
   module Layout #:nodoc:
     def self.included(base)
diff --git a/actionpack/lib/action_controller/base/redirect.rb b/actionpack/lib/action_controller/base/redirect.rb
index 2e92117e7c..7e10f614e2 100644
--- a/actionpack/lib/action_controller/base/redirect.rb
+++ b/actionpack/lib/action_controller/base/redirect.rb
@@ -48,8 +48,6 @@ module ActionController
         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 ("-")
@@ -72,7 +70,9 @@ module ActionController
     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))
+      response.status = interpret_status(status)
+      response.location = url.gsub(/[\r\n]/, '')
+      response.body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"      
       @performed_redirect = true
     end
     
@@ -82,8 +82,6 @@ module ActionController
     # 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
diff --git a/actionpack/lib/action_controller/base/render.rb b/actionpack/lib/action_controller/base/render.rb
index 4286577ec5..cc0d878e01 100644
--- a/actionpack/lib/action_controller/base/render.rb
+++ b/actionpack/lib/action_controller/base/render.rb
@@ -253,7 +253,8 @@ module ActionController
         response.content_type ||= Mime::JS
         render_for_text(js)
 
-      elsif json = options[:json]
+      elsif options.include?(:json)
+        json = options[:json]
         json = ActiveSupport::JSON.encode(json) unless json.respond_to?(:to_str)
         json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
         response.content_type ||= Mime::JSON
diff --git a/actionpack/lib/action_controller/base/rescue.rb b/actionpack/lib/action_controller/base/rescue.rb
new file mode 100644
index 0000000000..2717a06a37
--- /dev/null
+++ b/actionpack/lib/action_controller/base/rescue.rb
@@ -0,0 +1,50 @@
+module ActionController #:nodoc:
+  # Actions that fail to perform as expected throw exceptions. These
+  # exceptions can either be rescued for the public view (with a nice
+  # user-friendly explanation) or for the developers view (with tons of
+  # debugging information). The developers view is already implemented by
+  # the Action Controller, but the public view should be tailored to your
+  # specific application.
+  #
+  # The default behavior for public exceptions is to render a static html
+  # file with the name of the error code thrown.  If no such file exists, an
+  # empty response is sent with the correct status code.
+  #
+  # You can override what constitutes a local request by overriding the
+  # <tt>local_request?</tt> method in your own controller. Custom rescue
+  # behavior is achieved by overriding the <tt>rescue_action_in_public</tt>
+  # and <tt>rescue_action_locally</tt> methods.
+  module Rescue
+    def self.included(base) #:nodoc:
+      base.send :include, ActiveSupport::Rescuable
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        alias_method_chain :perform_action, :rescue
+      end
+    end
+
+    module ClassMethods
+      def rescue_action(env)
+        exception = env.delete('action_dispatch.rescue.exception')
+        request   = ActionDispatch::Request.new(env)
+        response  = ActionDispatch::Response.new
+        new.process(request, response, :rescue_action, exception).to_a
+      end
+    end
+
+    protected
+      # Exception handler called when the performance of an action raises
+      # an exception.
+      def rescue_action(exception)
+        rescue_with_handler(exception) || raise(exception)
+      end
+
+    private
+      def perform_action_with_rescue
+        perform_action_without_rescue
+      rescue Exception => exception
+        rescue_action(exception)
+      end
+  end
+end
diff --git a/actionpack/lib/action_controller/caching/actions.rb b/actionpack/lib/action_controller/caching/actions.rb
index d95a346862..2b822b52c8 100644
--- a/actionpack/lib/action_controller/caching/actions.rb
+++ b/actionpack/lib/action_controller/caching/actions.rb
@@ -61,7 +61,9 @@ module ActionController #:nodoc:
           filter_options = { :only => actions, :if => options.delete(:if), :unless => options.delete(:unless) }
 
           cache_filter = ActionCacheFilter.new(:layout => options.delete(:layout), :cache_path => options.delete(:cache_path), :store_options => options)
-          around_filter(cache_filter, filter_options)
+          around_filter(filter_options) do |controller, action|
+            cache_filter.filter(controller, action)
+          end
         end
       end
 
@@ -83,6 +85,12 @@ module ActionController #:nodoc:
           @options = options
         end
 
+        def filter(controller, action)
+          should_continue = before(controller)
+          action.call if should_continue
+          after(controller)
+        end
+
         def before(controller)
           cache_path = ActionCachePath.new(controller, path_options_for(controller, @options.slice(:cache_path)))
           if cache = controller.read_fragment(cache_path.path, @options[:store_options])
diff --git a/actionpack/lib/action_controller/dispatch/dispatcher.rb b/actionpack/lib/action_controller/dispatch/dispatcher.rb
index bb9d8bd063..63866caed9 100644
--- a/actionpack/lib/action_controller/dispatch/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatch/dispatcher.rb
@@ -5,9 +5,9 @@ module ActionController
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
-          unless self.middleware.include?(ActionDispatch::Reloader)
-            self.middleware.insert_after(ActionDispatch::Failsafe, ActionDispatch::Reloader)
-          end
+          # Development mode callbacks
+          before_dispatch :reload_application
+          after_dispatch :cleanup_application
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
@@ -40,53 +40,44 @@ module ActionController
       def run_prepare_callbacks
         new.send :run_callbacks, :prepare_dispatch
       end
-
-      def reload_application
-        # Run prepare callbacks before every request in development mode
-        run_prepare_callbacks
-
-        Routing::Routes.reload
-      end
-
-      def cleanup_application
-        # Cleanup the application before processing the current request.
-        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-        ActiveSupport::Dependencies.clear
-        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-      end
     end
 
+    cattr_accessor :router
+    self.router = Routing::Routes
+
     cattr_accessor :middleware
     self.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
       middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
-      middleware.instance_eval(File.read(middlewares))
+      middleware.instance_eval(File.read(middlewares), middlewares, 1)
     end
 
     include ActiveSupport::Callbacks
     define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
 
     def initialize
-      @app = @@middleware.build(lambda { |env| self._call(env) })
+      @app = @@middleware.build(@@router)
       freeze
     end
 
     def call(env)
+      run_callbacks :before_dispatch
       @app.call(env)
+    ensure
+      run_callbacks :after_dispatch, :enumerator => :reverse_each
     end
 
-    def _call(env)
-      begin
-        run_callbacks :before_dispatch
-        Routing::Routes.call(env)
-      rescue Exception => exception
-        if controller ||= (::ApplicationController rescue Base)
-          controller.call_with_exception(env, exception).to_a
-        else
-          raise exception
-        end
-      ensure
-        run_callbacks :after_dispatch, :enumerator => :reverse_each
-      end
+    def reload_application
+      # Run prepare callbacks before every request in development mode
+      run_callbacks :prepare_dispatch
+
+      @@router.reload
+    end
+
+    def cleanup_application
+      # Cleanup the application before processing the current request.
+      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+      ActiveSupport::Dependencies.clear
+      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
     end
 
     def flush_logger
diff --git a/actionpack/lib/action_controller/dispatch/middlewares.rb b/actionpack/lib/action_controller/dispatch/middlewares.rb
index b5adbae746..f99637b109 100644
--- a/actionpack/lib/action_controller/dispatch/middlewares.rb
+++ b/actionpack/lib/action_controller/dispatch/middlewares.rb
@@ -3,10 +3,15 @@ use "Rack::Lock", :if => lambda {
 }
 
 use "ActionDispatch::Failsafe"
+use "ActionDispatch::ShowExceptions", lambda { ActionController::Base.consider_all_requests_local }
+use "ActionDispatch::Rescue", lambda {
+  controller = (::ApplicationController rescue ActionController::Base)
+  controller.method(:rescue_action)
+}
 
 use lambda { ActionController::Base.session_store },
     lambda { ActionController::Base.session_options }
 
 use "ActionDispatch::ParamsParser"
 use "Rack::MethodOverride"
-use "Rack::Head"
+use "Rack::Head"
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/dispatch/rescue.rb b/actionpack/lib/action_controller/dispatch/rescue.rb
deleted file mode 100644
index df80ac0909..0000000000
--- a/actionpack/lib/action_controller/dispatch/rescue.rb
+++ /dev/null
@@ -1,185 +0,0 @@
-module ActionController #:nodoc:
-  # Actions that fail to perform as expected throw exceptions. These
-  # exceptions can either be rescued for the public view (with a nice
-  # user-friendly explanation) or for the developers view (with tons of
-  # debugging information). The developers view is already implemented by
-  # the Action Controller, but the public view should be tailored to your
-  # specific application.
-  #
-  # The default behavior for public exceptions is to render a static html
-  # file with the name of the error code thrown.  If no such file exists, an
-  # empty response is sent with the correct status code.
-  #
-  # You can override what constitutes a local request by overriding the
-  # <tt>local_request?</tt> method in your own controller. Custom rescue
-  # behavior is achieved by overriding the <tt>rescue_action_in_public</tt>
-  # and <tt>rescue_action_locally</tt> methods.
-  module Rescue
-    LOCALHOST = '127.0.0.1'.freeze
-
-    DEFAULT_RESCUE_RESPONSE = :internal_server_error
-    DEFAULT_RESCUE_RESPONSES = {
-      'ActionController::RoutingError'             => :not_found,
-      'ActionController::UnknownAction'            => :not_found,
-      'ActiveRecord::RecordNotFound'               => :not_found,
-      'ActiveRecord::StaleObjectError'             => :conflict,
-      'ActiveRecord::RecordInvalid'                => :unprocessable_entity,
-      'ActiveRecord::RecordNotSaved'               => :unprocessable_entity,
-      'ActionController::MethodNotAllowed'         => :method_not_allowed,
-      'ActionController::NotImplemented'           => :not_implemented,
-      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
-    }
-
-    DEFAULT_RESCUE_TEMPLATE = 'diagnostics'
-    DEFAULT_RESCUE_TEMPLATES = {
-      'ActionView::MissingTemplate'       => 'missing_template',
-      'ActionController::RoutingError'    => 'routing_error',
-      'ActionController::UnknownAction'   => 'unknown_action',
-      'ActionView::TemplateError'         => 'template_error'
-    }
-
-    RESCUES_TEMPLATE_PATH = ActionView::Template::FileSystemPath.new(
-      File.join(File.dirname(__FILE__), "templates"))
-
-    def self.included(base) #:nodoc:
-      base.cattr_accessor :rescue_responses
-      base.rescue_responses = Hash.new(DEFAULT_RESCUE_RESPONSE)
-      base.rescue_responses.update DEFAULT_RESCUE_RESPONSES
-
-      base.cattr_accessor :rescue_templates
-      base.rescue_templates = Hash.new(DEFAULT_RESCUE_TEMPLATE)
-      base.rescue_templates.update DEFAULT_RESCUE_TEMPLATES
-
-      base.extend(ClassMethods)
-      base.send :include, ActiveSupport::Rescuable
-
-      base.class_eval do
-        alias_method_chain :perform_action, :rescue
-      end
-    end
-
-    module ClassMethods
-      def call_with_exception(env, exception) #:nodoc:
-        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
-
-    protected
-      # Exception handler called when the performance of an action raises
-      # an exception.
-      def rescue_action(exception)
-        rescue_with_handler(exception) ||
-          rescue_action_without_handler(exception)
-      end
-
-      # Overwrite to implement custom logging of errors. By default
-      # logs as fatal.
-      def log_error(exception) #:doc:
-        ActiveSupport::Deprecation.silence do
-          if ActionView::TemplateError === exception
-            logger.fatal(exception.to_s)
-          else
-            logger.fatal(
-              "\n#{exception.class} (#{exception.message}):\n  " +
-              clean_backtrace(exception).join("\n  ") + "\n\n"
-            )
-          end
-        end
-      end
-
-      # Overwrite to implement public exception handling (for requests
-      # answering false to <tt>local_request?</tt>).  By default will call
-      # render_optional_error_file.  Override this method to provide more
-      # user friendly error messages.
-      def rescue_action_in_public(exception) #:doc:
-        render_optional_error_file response_code_for_rescue(exception)
-      end
-
-      # Attempts to render a static error page based on the
-      # <tt>status_code</tt> thrown, or just return headers if no such file
-      # exists. At first, it will try to render a localized static page.
-      # For example, if a 500 error is being handled Rails and locale is :da,
-      # it will first attempt to render the file at <tt>public/500.da.html</tt>
-      # then attempt to render <tt>public/500.html</tt>. If none of them exist,
-      # the body of the response will be left empty.
-      def render_optional_error_file(status_code)
-        status = interpret_status(status_code)
-        locale_path = "#{Rails.public_path}/#{status[0,3]}.#{I18n.locale}.html" if I18n.locale
-        path = "#{Rails.public_path}/#{status[0,3]}.html"
-
-        if locale_path && File.exist?(locale_path)
-          render :file => locale_path, :status => status, :content_type => Mime::HTML
-        elsif File.exist?(path)
-          render :file => path, :status => status, :content_type => Mime::HTML
-        else
-          head status
-        end
-      end
-
-      # True if the request came from localhost, 127.0.0.1. Override this
-      # method if you wish to redefine the meaning of a local request to
-      # include remote IP addresses or other criteria.
-      def local_request? #:doc:
-        request.remote_addr == LOCALHOST && request.remote_ip == LOCALHOST
-      end
-
-      # Render detailed diagnostics for unhandled exceptions rescued from
-      # a controller action.
-      def rescue_action_locally(exception)
-        @template.instance_variable_set("@exception", exception)
-        @template.instance_variable_set("@rescues_path", RESCUES_TEMPLATE_PATH)
-        @template.instance_variable_set("@contents",
-          @template._render_template(template_path_for_local_rescue(exception)))
-
-        response.content_type = Mime::HTML
-        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)
-        log_error(exception) if logger
-        erase_results if performed?
-
-        # Let the exception alter the response if it wants.
-        # For example, MethodNotAllowed sets the Allow header.
-        if exception.respond_to?(:handle_response!)
-          exception.handle_response!(response)
-        end
-
-        if consider_all_requests_local || local_request?
-          rescue_action_locally(exception)
-        else
-          rescue_action_in_public(exception)
-        end
-      end
-
-    private
-      def perform_action_with_rescue #:nodoc:
-        perform_action_without_rescue
-      rescue Exception => exception
-        rescue_action(exception)
-      end
-
-      def rescues_path(template_name)
-        RESCUES_TEMPLATE_PATH.find_by_parts("rescues/#{template_name}.erb")
-      end
-
-      def template_path_for_local_rescue(exception)
-        rescues_path(rescue_templates[exception.class.name])
-      end
-
-      def response_code_for_rescue(exception)
-        rescue_responses[exception.class.name]
-      end
-
-      def clean_backtrace(exception)
-        defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
-          Rails.backtrace_cleaner.clean(exception.backtrace) :
-          exception.backtrace
-      end
-  end
-end
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb
deleted file mode 100644
index e5c647c826..0000000000
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb
+++ /dev/null
@@ -1,10 +0,0 @@
-<h1>
-  <%=h @exception.class.to_s %>
-  <% if request.parameters['controller'] %>
-    in <%=h request.parameters['controller'].humanize %>Controller<% if request.parameters['action'] %>#<%=h request.parameters['action'] %><% end %>
-  <% end %>
-</h1>
-<pre><%=h @exception.clean_message %></pre>
-
-<%= @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/new_base.rb b/actionpack/lib/action_controller/new_base.rb
index 7c65f1cdc1..1f215bb6f1 100644
--- a/actionpack/lib/action_controller/new_base.rb
+++ b/actionpack/lib/action_controller/new_base.rb
@@ -1,7 +1,28 @@
 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
+  autoload :Base,                 "action_controller/new_base/base"
+  autoload :ConditionalGet,       "action_controller/new_base/conditional_get"
+  autoload :HideActions,          "action_controller/new_base/hide_actions"
+  autoload :Http,                 "action_controller/new_base/http"
+  autoload :Layouts,              "action_controller/new_base/layouts"
+  autoload :Rails2Compatibility,  "action_controller/new_base/compatibility"
+  autoload :Redirector,           "action_controller/new_base/redirector"
+  autoload :Renderer,             "action_controller/new_base/renderer"
+  autoload :Testing,              "action_controller/new_base/testing"
+  autoload :UrlFor,               "action_controller/new_base/url_for"
+  
+  # Ported modules
+  # require 'action_controller/routing'
+  autoload :Dispatcher,        'action_controller/dispatch/dispatcher'
+  autoload :PolymorphicRoutes, 'action_controller/routing/generation/polymorphic_routes'
+  autoload :RecordIdentifier,  'action_controller/record_identifier'
+  autoload :Resources,         'action_controller/routing/resources'
+  autoload :SessionManagement, 'action_controller/base/session_management'
+  autoload :TestCase,          'action_controller/testing/test_case'
+  autoload :UrlRewriter,       'action_controller/routing/generation/url_rewriter'
+  autoload :UrlWriter,         'action_controller/routing/generation/url_rewriter'
+  
+  require 'action_controller/routing'
+end
+
+require 'action_dispatch'
+require 'action_view'
\ 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
index 08e7a1a0e7..1adcc9c71f 100644
--- a/actionpack/lib/action_controller/new_base/base.rb
+++ b/actionpack/lib/action_controller/new_base/base.rb
@@ -1,60 +1,127 @@
 module ActionController
-  class AbstractBase < AbstractController::Base
+  class Base < Http
+    abstract!
     
-    # :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
+    include AbstractController::Callbacks
+    include AbstractController::Helpers
+    include AbstractController::Logger
     
-    # :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)
+    include ActionController::HideActions
+    include ActionController::UrlFor
+    include ActionController::Redirector
+    include ActionController::Renderer
+    include ActionController::Layouts
+    include ActionController::ConditionalGet
+    
+    # Legacy modules
+    include SessionManagement
+    include ActionDispatch::StatusCodes
+    
+    # Rails 2.x compatibility
+    include ActionController::Rails2Compatibility
+    
+    def self.inherited(klass)
+      ::ActionController::Base.subclasses << klass.to_s
+      super
     end
     
-    # :api: private    
-    def self.action_names() action_methods end
+    def self.subclasses
+      @subclasses ||= []
+    end
     
-    # :api: private        
-    def action_methods() self.class.action_names end
-
-    # :api: private
-    def action_names() action_methods end
+    def self.app_loaded!
+      @subclasses.each do |subclass|
+        subclass.constantize._write_layout_method
+      end
+    end
     
-    # :api: plugin
-    def self.call(env)
-      controller = new
-      controller.call(env).to_rack
+    def render_to_body(action = nil, options = {})
+      if action.is_a?(Hash)
+        options, action = action, nil 
+      elsif action.is_a?(String) || action.is_a?(Symbol)
+        key = case action = action.to_s
+        when %r{^/} then :file
+        when %r{/}  then :template
+        else             :action
+        end        
+        options.merge! key => action
+      elsif action
+        options.merge! :partial => action
+      end
+      
+      if options.key?(:action) && options[:action].to_s.index("/")
+        options[:template] = options.delete(:action)
+      end
+      
+      # options = {:template => options.to_s} if options.is_a?(String) || options.is_a?(Symbol)
+      super(options) || " "
     end
     
-    # :api: plugin
-    def response_body=(body)
-      @_response.body = body
+    # 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?
+
+      status = if options.is_a?(Hash) && options.key?(:status)
+        interpret_status(options.delete(:status))
+      elsif response_status.key?(:status)
+        interpret_status(response_status[:status])
+      else
+        302
+      end
+
+      url = 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+.-]*:.*}
+        options
+      when String
+        request.protocol + request.host_with_port + options
+      when :back
+        raise RedirectBackError unless refer = request.headers["Referer"]
+        refer
+      else
+        url_for(options)
+      end
+      
+      super(url, status)
     end
     
-    # :api: private
-    def call(env)
-      @_request = ActionDispatch::Request.new(env)
-      @_response = ActionDispatch::Response.new
-      process(@_request.parameters[:action])
+    def process_action
+      ret = super
+      render if response_body.nil?
+      ret
     end
     
-    # :api: private
-    def to_rack
-      response.to_a
+    def respond_to_action?(action_name)
+      super || view_paths.find_by_parts?(action_name.to_s, {:formats => formats, :locales => [I18n.locale]}, controller_path)
     end
   end
-end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/compatibility.rb b/actionpack/lib/action_controller/new_base/compatibility.rb
new file mode 100644
index 0000000000..993e571aba
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/compatibility.rb
@@ -0,0 +1,91 @@
+module ActionController
+  module Rails2Compatibility
+    extend ActiveSupport::DependencyModule
+  
+    # Temporary hax
+    included do
+      ::ActionController::UnknownAction = ::AbstractController::ActionNotFound
+      ::ActionController::DoubleRenderError = ::AbstractController::DoubleRenderError
+      
+      cattr_accessor :session_options
+      self.session_options = {}
+      
+      cattr_accessor :allow_concurrency
+      self.allow_concurrency = false
+      
+      cattr_accessor :param_parsers
+      self.param_parsers = { Mime::MULTIPART_FORM   => :multipart_form,
+                             Mime::URL_ENCODED_FORM => :url_encoded_form,
+                             Mime::XML              => :xml_simple,
+                             Mime::JSON             => :json }
+                          
+      cattr_accessor :relative_url_root
+      self.relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
+      
+      cattr_accessor :default_charset
+      self.default_charset = "utf-8"
+      
+      # cattr_reader :protected_instance_variables
+      cattr_accessor :protected_instance_variables
+      self.protected_instance_variables = %w(@assigns @performed_redirect @performed_render @variables_added @request_origin @url @parent_controller
+                                          @action_name @before_filter_chain_aborted @action_cache_path @_headers @_params
+                                          @_flash @_response)
+                                          
+      # Indicates whether or not optimise the generated named
+      # route helper methods
+      cattr_accessor :optimise_named_routes
+      self.optimise_named_routes = true
+      
+      cattr_accessor :resources_path_names
+      self.resources_path_names = { :new => 'new', :edit => 'edit' }
+      
+      # Controls the resource action separator
+      cattr_accessor :resource_action_separator
+      self.resource_action_separator = "/"
+      
+      cattr_accessor :use_accept_header
+      self.use_accept_header = true
+    end
+    
+    module ClassMethods
+      def protect_from_forgery() end
+      def consider_all_requests_local() end
+      def rescue_action(env)
+        raise env["action_dispatch.rescue.exception"]
+      end
+    end
+    
+    def initialize(*)
+      super
+      @template = _action_view
+    end
+    
+    def render_to_body(options)
+      if options.is_a?(Hash) && options.key?(:template)
+        options[:template].sub!(/^\//, '')
+      end
+      
+      options[:text] = nil if options[:nothing] == true
+
+      super
+    end
+    
+    def respond_to_action?(action_name)
+      if respond_to?(:method_missing) && !respond_to?(:action_missing)
+        self.class.class_eval do
+          private
+          def action_missing(name, *args)
+            method_missing(name.to_sym, *args)
+          end
+        end
+      end
+      super
+    end    
+      
+    def _layout_for_name(name)
+      name &&= name.sub(%r{^/?layouts/}, '')
+      super
+    end
+   
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/conditional_get.rb b/actionpack/lib/action_controller/new_base/conditional_get.rb
new file mode 100644
index 0000000000..e1407e671a
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/conditional_get.rb
@@ -0,0 +1,131 @@
+module ActionController
+  module ConditionalGet
+    
+    # Sets the etag, last_modified, or both on the response and renders a
+    # "304 Not Modified" response if the request is already fresh.
+    #
+    # Parameters:
+    # * <tt>:etag</tt>
+    # * <tt>:last_modified</tt> 
+    # * <tt>:public</tt> By default the Cache-Control header is private, set this to true if you want your application to be cachable by other devices (proxy caches).
+    #
+    # Example:
+    #
+    #   def show
+    #     @article = Article.find(params[:id])
+    #     fresh_when(:etag => @article, :last_modified => @article.created_at.utc, :public => true)
+    #   end
+    #
+    # This will render the show template if the request isn't sending a matching etag or
+    # If-Modified-Since header and just a "304 Not Modified" response if there's a match.
+    #    
+    def fresh_when(options)
+      options.assert_valid_keys(:etag, :last_modified, :public)
+
+      response.etag          = options[:etag]          if options[:etag]
+      response.last_modified = options[:last_modified] if options[:last_modified]
+      
+      if options[:public] 
+        cache_control = response.headers["Cache-Control"].split(",").map {|k| k.strip }
+        cache_control.delete("private")
+        cache_control.delete("no-cache")
+        cache_control << "public"
+        response.headers["Cache-Control"] = cache_control.join(', ')
+      end
+
+      if request.fresh?(response)
+        head :not_modified
+      end
+    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   
+    
+    # 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,
+    # it's fresh and we don't need to generate anything and a reply of "304 Not Modified" is sent.
+    #
+    # Parameters:
+    # * <tt>:etag</tt>
+    # * <tt>:last_modified</tt> 
+    # * <tt>:public</tt> By default the Cache-Control header is private, set this to true if you want your application to be cachable by other devices (proxy caches).
+    #
+    # Example:
+    #
+    #   def show
+    #     @article = Article.find(params[:id])
+    #
+    #     if stale?(:etag => @article, :last_modified => @article.created_at.utc)
+    #       @statistics = @article.really_expensive_call
+    #       respond_to do |format|
+    #         # all the supported formats
+    #       end
+    #     end
+    #   end
+    def stale?(options)
+      fresh_when(options)
+      !request.fresh?(response)
+    end
+    
+    # Sets a HTTP 1.1 Cache-Control header. Defaults to issuing a "private" instruction, so that
+    # intermediate caches shouldn't cache the response.
+    #
+    # Examples:
+    #   expires_in 20.minutes
+    #   expires_in 3.hours, :public => true
+    #   expires in 3.hours, 'max-stale' => 5.hours, :public => true
+    #
+    # This method will overwrite an existing Cache-Control header.
+    # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
+    def expires_in(seconds, options = {}) #:doc:
+      cache_control = response.headers["Cache-Control"].split(",").map {|k| k.strip }
+
+      cache_control << "max-age=#{seconds}"
+      cache_control.delete("no-cache")
+      if options[:public]
+        cache_control.delete("private")
+        cache_control << "public"
+      else
+        cache_control << "private"
+      end
+      
+      # This allows for additional headers to be passed through like 'max-stale' => 5.hours
+      cache_control += options.symbolize_keys.reject{|k,v| k == :public || k == :private }.map{ |k,v| v == true ? k.to_s : "#{k.to_s}=#{v.to_s}"}
+      
+      response.headers["Cache-Control"] = cache_control.join(', ')
+    end
+
+    # Sets a HTTP 1.1 Cache-Control header of "no-cache" so no caching should occur by the browser or
+    # intermediate caches (like caching proxy servers).
+    def expires_now #:doc:
+      response.headers["Cache-Control"] = "no-cache"
+    end
+    
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/hide_actions.rb b/actionpack/lib/action_controller/new_base/hide_actions.rb
index 473a8ea72b..a29b09a893 100644
--- a/actionpack/lib/action_controller/new_base/hide_actions.rb
+++ b/actionpack/lib/action_controller/new_base/hide_actions.rb
@@ -1,17 +1,19 @@
 module ActionController
   module HideActions
-    setup do
+    extend ActiveSupport::DependencyModule
+
+    included do
       extlib_inheritable_accessor :hidden_actions
-      self.hidden_actions ||= Set.new      
+      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))
+    def action_method?(action_name)
+      !hidden_actions.include?(action_name) && super
     end
     
     module ClassMethods
diff --git a/actionpack/lib/action_controller/new_base/http.rb b/actionpack/lib/action_controller/new_base/http.rb
new file mode 100644
index 0000000000..e9a1d5b12f
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/http.rb
@@ -0,0 +1,68 @@
+require 'action_controller/abstract'
+require 'active_support/core_ext/module/delegation'
+
+module ActionController
+  class Http < AbstractController::Base
+    abstract!
+    
+    # :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_names() action_methods end
+    
+    # :api: private
+    def action_names() action_methods end
+    
+    # :api: plugin
+    def self.call(env)
+      controller = new
+      controller.call(env).to_rack
+    end
+    
+    delegate :headers, :to => "@_response"
+    
+    def params
+      @_params ||= @_request.parameters
+    end
+    
+    # :api: private
+    def call(name, env)
+      @_request = ActionDispatch::Request.new(env)
+      @_response = ActionDispatch::Response.new
+      @_response.request = request
+      process(name)
+      @_response.body = response_body
+      @_response.prepare!
+      to_rack
+    end
+    
+    def self.action(name)
+      @actions ||= {}
+      @actions[name.to_s] ||= proc do |env|
+        new.call(name, env)
+      end
+    end
+    
+    # :api: private
+    def to_rack
+      @_response.to_a
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/layouts.rb b/actionpack/lib/action_controller/new_base/layouts.rb
index a8e0809ac6..bf5b14c4e1 100644
--- a/actionpack/lib/action_controller/new_base/layouts.rb
+++ b/actionpack/lib/action_controller/new_base/layouts.rb
@@ -1,5 +1,7 @@
 module ActionController
   module Layouts
+    extend ActiveSupport::DependencyModule
+
     depends_on ActionController::Renderer
     depends_on AbstractController::Layouts
     
@@ -13,7 +15,7 @@ module ActionController
       # render :text => ..., :layout => ...
       # or
       # render :anything_else
-      if !options.key?(:text) || options.key?(:layout)
+      if (!options.key?(:text) && !options.key?(:inline) && !options.key?(:partial)) || options.key?(:layout)
         options[:_layout] = options.key?(:layout) ? _layout_for_option(options[:layout]) : _default_layout
       end
       
diff --git a/actionpack/lib/action_controller/new_base/redirector.rb b/actionpack/lib/action_controller/new_base/redirector.rb
new file mode 100644
index 0000000000..ff7b74341c
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/redirector.rb
@@ -0,0 +1,19 @@
+module ActionController
+  class RedirectBackError < AbstractController::Error #: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
+    def redirect_to(url, status) #:doc:
+      raise AbstractController::DoubleRenderError if response_body
+      logger.info("Redirected to #{url}") if logger && logger.info?
+      response.status = status
+      response.location = url.gsub(/[\r\n]/, '')
+      self.response_body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/renderer.rb b/actionpack/lib/action_controller/new_base/renderer.rb
index ed34c46aed..8a9f230603 100644
--- a/actionpack/lib/action_controller/new_base/renderer.rb
+++ b/actionpack/lib/action_controller/new_base/renderer.rb
@@ -1,5 +1,7 @@
 module ActionController
   module Renderer
+    extend ActiveSupport::DependencyModule
+
     depends_on AbstractController::Renderer
     
     def initialize(*)
@@ -7,35 +9,32 @@ module ActionController
       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
-      
+    def render_to_body(options)
       _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?(:inline)
+        handler = ActionView::Template.handler_class_for_extension(options[:type] || "erb")
+        template = ActionView::Template.new(options[:inline], "inline #{options[:inline].inspect}", handler, {})
+        options[:_template] = template
       elsif options.key?(:template)
         options[:_template_name] = options[:template]
-      elsif options.key?(:action)
-        options[:_template_name] = options[:action].to_s
+      elsif options.key?(:file)
+        options[:_template_name] = options[:file]
+      elsif options.key?(:partial)
+        _render_partial(options[:partial], options)
+      else
+        options[:_template_name] = (options[:action] || action_name).to_s
         options[:_prefix] = _prefix 
       end
       
-      super(options)
+      ret = super(options)
+      
+      options[:_template] ||= _action_view._partial
+      response.content_type ||= options[:_template].mime_type
+      ret
     end
     
   private
@@ -52,11 +51,26 @@ module ActionController
       else text.to_s
       end
     end
+    
+    def _render_partial(partial, options)
+      case partial
+      when true
+        options[:_prefix] = _prefix
+      when String
+        options[:_prefix] = _prefix unless partial.index('/')
+        options[:_template_name] = partial
+      else
+        options[:_partial_object] = true
+        return
+      end
+      
+      options[:_partial] = options[:object] || true
+    end
   
     def _process_options(options)
-      if status = options[:status]
-        response.status = status.to_i
-      end
+      status, content_type = options.values_at(:status, :content_type)
+      response.status = status.to_i if status
+      response.content_type = content_type if content_type
     end
   end
 end
diff --git a/actionpack/lib/action_controller/new_base/testing.rb b/actionpack/lib/action_controller/new_base/testing.rb
new file mode 100644
index 0000000000..106990b9ba
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/testing.rb
@@ -0,0 +1,25 @@
+module ActionController
+  module Testing
+    
+    # OMG MEGA HAX
+    def process_with_test(request, response)
+      @_request = request
+      @_response = response
+      @_response.request = request
+      ret = process(request.parameters[:action])
+      @_response.body = self.response_body
+      @_response.prepare!
+      set_test_assigns
+      ret
+    end
+    
+    def set_test_assigns
+      @assigns = {}
+      (instance_variable_names - self.class.protected_instance_variables).each do |var|
+        name, value = var[1..-1], instance_variable_get(var)
+        @assigns[name] = value
+      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 6bda27e23a..b4408e4e1d 100644
--- a/actionpack/lib/action_controller/record_identifier.rb
+++ b/actionpack/lib/action_controller/record_identifier.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module'
+
 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
diff --git a/actionpack/lib/action_controller/routing.rb b/actionpack/lib/action_controller/routing.rb
index 82b36131f5..5b9ded83dd 100644
--- a/actionpack/lib/action_controller/routing.rb
+++ b/actionpack/lib/action_controller/routing.rb
@@ -1,5 +1,9 @@
 require 'cgi'
 require 'uri'
+require 'set'
+
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'action_controller/routing/optimisations'
 require 'action_controller/routing/routing_ext'
 require 'action_controller/routing/route'
diff --git a/actionpack/lib/action_controller/routing/builder.rb b/actionpack/lib/action_controller/routing/builder.rb
index d9590c88b8..42ad12e1ea 100644
--- a/actionpack/lib/action_controller/routing/builder.rb
+++ b/actionpack/lib/action_controller/routing/builder.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/except'
+
 module ActionController
   module Routing
     class RouteBuilder #:nodoc:
diff --git a/actionpack/lib/action_controller/routing/route.rb b/actionpack/lib/action_controller/routing/route.rb
index e2077edad8..eba05a3c5a 100644
--- a/actionpack/lib/action_controller/routing/route.rb
+++ b/actionpack/lib/action_controller/routing/route.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/misc'
+
 module ActionController
   module Routing
     class Route #:nodoc:
@@ -65,7 +67,7 @@ module ActionController
       #   map.connect '/page/:id', :controller => 'pages', :action => 'show', :id => /\d+/
       #
       def parameter_shell
-        @parameter_shell ||= returning({}) do |shell|
+        @parameter_shell ||= {}.tap do |shell|
           requirements.each do |key, requirement|
             shell[key] = requirement unless requirement.is_a? Regexp
           end
@@ -76,7 +78,7 @@ module ActionController
       # includes keys that appear inside the path, and keys that have requirements
       # placed upon them.
       def significant_keys
-        @significant_keys ||= returning([]) do |sk|
+        @significant_keys ||= [].tap do |sk|
           segments.each { |segment| sk << segment.key if segment.respond_to? :key }
           sk.concat requirements.keys
           sk.uniq!
@@ -86,7 +88,7 @@ module ActionController
       # Return a hash of key/value pairs representing the keys in the route that
       # have defaults, or which are specified by non-regexp requirements.
       def defaults
-        @defaults ||= returning({}) do |hash|
+        @defaults ||= {}.tap do |hash|
           segments.each do |segment|
             next unless segment.respond_to? :default
             hash[segment.key] = segment.default unless segment.default.nil?
diff --git a/actionpack/lib/action_controller/routing/route_set.rb b/actionpack/lib/action_controller/routing/route_set.rb
index e2ecc77eb1..fb344f6c6b 100644
--- a/actionpack/lib/action_controller/routing/route_set.rb
+++ b/actionpack/lib/action_controller/routing/route_set.rb
@@ -430,7 +430,7 @@ module ActionController
       def call(env)
         request = ActionDispatch::Request.new(env)
         app = Routing::Routes.recognize(request)
-        app.call(env).to_a
+        app.action(request.parameters[:action] || 'index').call(env)
       end
 
       def recognize(request)
diff --git a/actionpack/lib/action_controller/testing/assertions/response.rb b/actionpack/lib/action_controller/testing/assertions/response.rb
deleted file mode 100644
index 684fe1ffe0..0000000000
--- a/actionpack/lib/action_controller/testing/assertions/response.rb
+++ /dev/null
@@ -1,162 +0,0 @@
-module ActionController
-  module Assertions
-    # A small suite of assertions that test responses from Rails applications.
-    module ResponseAssertions
-      # Asserts that the response is one of the following types:
-      #
-      # * <tt>:success</tt>   - Status code was 200
-      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
-      # * <tt>:missing</tt>   - Status code was 404
-      # * <tt>:error</tt>     - Status code was in the 500-599 range
-      #
-      # You can also pass an explicit status number like assert_response(501)
-      # or its symbolic equivalent assert_response(:not_implemented).
-      # See ActionDispatch::StatusCodes for a full list.
-      #
-      # ==== Examples
-      #
-      #   # assert that the response was a redirection
-      #   assert_response :redirect
-      #
-      #   # assert that the response code was status code 401 (unauthorized)
-      #   assert_response 401
-      #
-      def assert_response(type, message = nil)
-        validate_request!
-
-        clean_backtrace do
-          if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
-            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 == ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
-            assert_block("") { true } # to count the assertion
-          else
-            if @controller && @response.error?
-              exception = @controller.template.instance_variable_get(:@exception)
-              exception_message = exception && exception.message
-              assert_block(build_message(message, "Expected response to be a <?>, but was <?>\n<?>", type, @response.response_code, exception_message.to_s)) { false }
-            else
-              assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
-            end
-          end
-        end
-      end
-
-      # Assert that the redirection options passed in match those of the redirect called in the latest action.
-      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
-      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
-      #
-      # ==== Examples
-      #
-      #   # assert that the redirection was to the "index" action on the WeblogController
-      #   assert_redirected_to :controller => "weblog", :action => "index"
-      #
-      #   # assert that the redirection was to the named route login_url
-      #   assert_redirected_to login_url
-      #
-      #   # assert that the redirection was to the url for @customer
-      #   assert_redirected_to @customer
-      #
-      def assert_redirected_to(options = {}, message=nil)
-        validate_request!
-
-        clean_backtrace do
-          assert_response(:redirect, message)
-          return true if options == @response.redirected_to
-
-          # Support partial arguments for hash redirections
-          if options.is_a?(Hash) && @response.redirected_to.is_a?(Hash)
-            return true if options.all? {|(key, value)| @response.redirected_to[key] == value}
-          end
-
-          redirected_to_after_normalisation = normalize_argument_to_redirection(@response.redirected_to)
-          options_after_normalisation       = normalize_argument_to_redirection(options)
-
-          if redirected_to_after_normalisation != options_after_normalisation
-            flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
-          end
-        end
-      end
-
-      # Asserts that the request was rendered with the appropriate template file or partials
-      #
-      # ==== Examples
-      #
-      #   # assert that the "new" view template was rendered
-      #   assert_template "new"
-      #
-      #   # assert that the "_customer" partial was rendered twice
-      #   assert_template :partial => '_customer', :count => 2
-      #
-      #   # assert that no partials were rendered
-      #   assert_template :partial => false
-      #
-      def assert_template(options = {}, message = nil)
-        validate_request!
-
-        clean_backtrace do
-          case options
-           when NilClass, String
-            rendered = (@controller.template.rendered[:template] || []).map { |t| t.identifier }
-            msg = build_message(message,
-                    "expecting <?> but rendering with <?>",
-                    options, rendered.join(', '))
-            assert_block(msg) do
-              if options.nil?
-                @controller.template.rendered[:template].blank?
-              else
-                rendered.any? { |t| t.match(options) }
-              end
-            end
-          when Hash
-            if expected_partial = options[:partial]
-              partials = @controller.template.rendered[:partials]
-              if expected_count = options[:count]
-                found = partials.detect { |p, _| p.identifier.match(expected_partial) }
-                actual_count = found.nil? ? 0 : found.second
-                msg = build_message(message,
-                        "expecting ? to be rendered ? time(s) but rendered ? time(s)",
-                         expected_partial, expected_count, actual_count)
-                assert(actual_count == expected_count.to_i, msg)
-              else
-                msg = build_message(message,
-                        "expecting partial <?> but action rendered <?>",
-                        options[:partial], partials.keys)
-                assert(partials.keys.any? { |p| p.identifier.match(expected_partial) }, msg)
-              end
-            else
-              assert @controller.template.rendered[:partials].empty?,
-                "Expected no partials to be rendered"
-            end
-          end
-        end
-      end
-
-      private
-        # Proxy to to_param if the object will respond to it.
-        def parameterize(value)
-          value.respond_to?(:to_param) ? value.to_param : value
-        end
-
-        def normalize_argument_to_redirection(fragment)
-          after_routing = @controller.url_for(fragment)
-          if after_routing =~ %r{^\w+://.*}
-            after_routing
-          else
-            # FIXME - this should probably get removed.
-            if after_routing.first != '/'
-              after_routing = '/' + after_routing
-            end
-            @request.protocol + @request.host_with_port + after_routing
-          end
-        end
-
-        def validate_request!
-          unless @request.is_a?(ActionDispatch::Request)
-            raise ArgumentError, "@request must be an ActionDispatch::Request"
-          end
-        end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/testing/integration.rb b/actionpack/lib/action_controller/testing/integration.rb
index 037463e489..d6991ab4f5 100644
--- a/actionpack/lib/action_controller/testing/integration.rb
+++ b/actionpack/lib/action_controller/testing/integration.rb
@@ -4,6 +4,114 @@ require 'active_support/test_case'
 
 module ActionController
   module Integration #:nodoc:
+    module RequestHelpers
+      # Performs a GET request with the given parameters.
+      #
+      # - +path+: The URI (as a String) on which you want to perform a GET
+      #   request.
+      # - +parameters+: The HTTP parameters that you want to pass. This may
+      #   be +nil+,
+      #   a Hash, or a String that is appropriately encoded
+      #   (<tt>application/x-www-form-urlencoded</tt> or
+      #   <tt>multipart/form-data</tt>).
+      # - +headers+: Additional HTTP headers to pass, as a Hash. The keys will
+      #   automatically be upcased, with the prefix 'HTTP_' added if needed.
+      #
+      # This method returns an Response object, which one can use to
+      # inspect the details of the response. Furthermore, if this method was
+      # called from an ActionController::IntegrationTest object, then that
+      # object's <tt>@response</tt> instance variable will point to the same
+      # response object.
+      #
+      # You can also perform POST, PUT, DELETE, and HEAD requests with +post+,
+      # +put+, +delete+, and +head+.
+      def get(path, parameters = nil, headers = nil)
+        process :get, path, parameters, headers
+      end
+
+      # Performs a POST request with the given parameters. See get() for more
+      # details.
+      def post(path, parameters = nil, headers = nil)
+        process :post, path, parameters, headers
+      end
+
+      # Performs a PUT request with the given parameters. See get() for more
+      # details.
+      def put(path, parameters = nil, headers = nil)
+        process :put, path, parameters, headers
+      end
+
+      # Performs a DELETE request with the given parameters. See get() for
+      # more details.
+      def delete(path, parameters = nil, headers = nil)
+        process :delete, path, parameters, headers
+      end
+
+      # Performs a HEAD request with the given parameters. See get() for more
+      # details.
+      def head(path, parameters = nil, headers = nil)
+        process :head, path, parameters, headers
+      end
+
+      # Performs an XMLHttpRequest request with the given parameters, mirroring
+      # a request from the Prototype library.
+      #
+      # The request_method is :get, :post, :put, :delete or :head; the
+      # parameters are +nil+, a hash, or a url-encoded or multipart string;
+      # the headers are a hash.  Keys are automatically upcased and prefixed
+      # with 'HTTP_' if not already.
+      def xml_http_request(request_method, path, parameters = nil, headers = nil)
+        headers ||= {}
+        headers['X-Requested-With'] = 'XMLHttpRequest'
+        headers['Accept'] ||= [Mime::JS, Mime::HTML, Mime::XML, 'text/xml', Mime::ALL].join(', ')
+        process(request_method, path, parameters, headers)
+      end
+      alias xhr :xml_http_request
+
+      # Follow a single redirect response. If the last response was not a
+      # redirect, an exception will be raised. Otherwise, the redirect is
+      # performed on the location header.
+      def follow_redirect!
+        raise "not a redirect! #{status} #{status_message}" unless redirect?
+        get(response.location)
+        status
+      end
+
+      # Performs a request using the specified method, following any subsequent
+      # redirect. Note that the redirects are followed until the response is
+      # not a redirect--this means you may run into an infinite loop if your
+      # redirect loops back to itself.
+      def request_via_redirect(http_method, path, parameters = nil, headers = nil)
+        process(http_method, path, parameters, headers)
+        follow_redirect! while redirect?
+        status
+      end
+
+      # Performs a GET request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def get_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:get, path, parameters, headers)
+      end
+
+      # Performs a POST request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def post_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:post, path, parameters, headers)
+      end
+
+      # Performs a PUT request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def put_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:put, path, parameters, headers)
+      end
+
+      # Performs a DELETE request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def delete_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:delete, path, parameters, headers)
+      end
+    end
+
     # An integration Session instance represents a set of requests and responses
     # performed sequentially by some virtual user. Because you can instantiate
     # multiple sessions and run them side-by-side, you can also mimic (to some
@@ -14,20 +122,17 @@ module ActionController
     # Integration::Session directly.
     class Session
       include Test::Unit::Assertions
-      include ActionController::TestCase::Assertions
+      include ActionDispatch::Assertions
       include ActionController::TestProcess
+      include RequestHelpers
 
-      # The integer HTTP status code of the last request.
-      attr_reader :status
-
-      # The status message that accompanied the status code of the last request.
-      attr_reader :status_message
-
-      # The body of the last request.
-      attr_reader :body
+      %w( status status_message headers body redirect? ).each do |method|
+        delegate method, :to => :response, :allow_nil => true
+      end
 
-      # The URI of the last request.
-      attr_reader :path
+      %w( path ).each do |method|
+        delegate method, :to => :request, :allow_nil => true
+      end
 
       # The hostname used in the last request.
       attr_accessor :host
@@ -42,9 +147,6 @@ module ActionController
       # sent with the next request.
       attr_reader :cookies
 
-      # A map of the headers returned by the last response.
-      attr_reader :headers
-
       # A reference to the controller instance used by the last request.
       attr_reader :controller
 
@@ -69,8 +171,6 @@ module ActionController
       #
       #   session.reset!
       def reset!
-        @status = @path = @headers = nil
-        @result = @status_message = nil
         @https = false
         @cookies = {}
         @controller = @request = @response = nil
@@ -118,117 +218,6 @@ module ActionController
         @host = name
       end
 
-      # Follow a single redirect response. If the last response was not a
-      # redirect, an exception will be raised. Otherwise, the redirect is
-      # performed on the location header.
-      def follow_redirect!
-        raise "not a redirect! #{@status} #{@status_message}" unless redirect?
-        get(interpret_uri(headers['location']))
-        status
-      end
-
-      # Performs a request using the specified method, following any subsequent
-      # redirect. Note that the redirects are followed until the response is
-      # not a redirect--this means you may run into an infinite loop if your
-      # redirect loops back to itself.
-      def request_via_redirect(http_method, path, parameters = nil, headers = nil)
-        send(http_method, path, parameters, headers)
-        follow_redirect! while redirect?
-        status
-      end
-
-      # Performs a GET request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def get_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:get, path, parameters, headers)
-      end
-
-      # Performs a POST request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def post_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:post, path, parameters, headers)
-      end
-
-      # Performs a PUT request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def put_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:put, path, parameters, headers)
-      end
-
-      # Performs a DELETE request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def delete_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:delete, path, parameters, headers)
-      end
-
-      # Returns +true+ if the last response was a redirect.
-      def redirect?
-        status/100 == 3
-      end
-
-      # Performs a GET request with the given parameters.
-      #
-      # - +path+: The URI (as a String) on which you want to perform a GET
-      #   request.
-      # - +parameters+: The HTTP parameters that you want to pass. This may
-      #   be +nil+,
-      #   a Hash, or a String that is appropriately encoded
-      #   (<tt>application/x-www-form-urlencoded</tt> or
-      #   <tt>multipart/form-data</tt>).
-      # - +headers+: Additional HTTP headers to pass, as a Hash. The keys will
-      #   automatically be upcased, with the prefix 'HTTP_' added if needed.
-      #
-      # This method returns an Response object, which one can use to
-      # inspect the details of the response. Furthermore, if this method was
-      # called from an ActionController::IntegrationTest object, then that
-      # object's <tt>@response</tt> instance variable will point to the same
-      # response object.
-      #
-      # You can also perform POST, PUT, DELETE, and HEAD requests with +post+,
-      # +put+, +delete+, and +head+.
-      def get(path, parameters = nil, headers = nil)
-        process :get, path, parameters, headers
-      end
-
-      # Performs a POST request with the given parameters. See get() for more
-      # details.
-      def post(path, parameters = nil, headers = nil)
-        process :post, path, parameters, headers
-      end
-
-      # Performs a PUT request with the given parameters. See get() for more
-      # details.
-      def put(path, parameters = nil, headers = nil)
-        process :put, path, parameters, headers
-      end
-
-      # Performs a DELETE request with the given parameters. See get() for
-      # more details.
-      def delete(path, parameters = nil, headers = nil)
-        process :delete, path, parameters, headers
-      end
-
-      # Performs a HEAD request with the given parameters. See get() for more
-      # details.
-      def head(path, parameters = nil, headers = nil)
-        process :head, path, parameters, headers
-      end
-
-      # Performs an XMLHttpRequest request with the given parameters, mirroring
-      # a request from the Prototype library.
-      #
-      # The request_method is :get, :post, :put, :delete or :head; the
-      # parameters are +nil+, a hash, or a url-encoded or multipart string;
-      # the headers are a hash.  Keys are automatically upcased and prefixed
-      # with 'HTTP_' if not already.
-      def xml_http_request(request_method, path, parameters = nil, headers = nil)
-        headers ||= {}
-        headers['X-Requested-With'] = 'XMLHttpRequest'
-        headers['Accept'] ||= [Mime::JS, Mime::HTML, Mime::XML, 'text/xml', Mime::ALL].join(', ')
-        process(request_method, path, parameters, headers)
-      end
-      alias xhr :xml_http_request
-
       # Returns the URL for the given options, according to the rules specified
       # in the application's routes.
       def url_for(options)
@@ -238,19 +227,14 @@ module ActionController
       end
 
       private
-        # Tailors the session based on the given URI, setting the HTTPS value
-        # and the hostname.
-        def interpret_uri(path)
-          location = URI.parse(path)
-          https! URI::HTTPS === location if location.scheme
-          host! location.host if location.host
-          location.query ? "#{location.path}?#{location.query}" : location.path
-        end
-
         # Performs the actual request.
         def process(method, path, parameters = nil, headers = nil)
-          path = interpret_uri(path) if path =~ %r{://}
-          @path = path
+          if path =~ %r{://}
+            location = URI.parse(path)
+            https! URI::HTTPS === location if location.scheme
+            host! location.host if location.host
+            path = location.query ? "#{location.path}?#{location.query}" : location.path
+          end
 
           [ControllerCapture, ActionController::ProcessWithTest].each do |mod|
             unless ActionController::Base < mod
@@ -261,7 +245,7 @@ module ActionController
           ActionController::Base.clear_last_instantiation!
 
           opts = {
-            :method => method.to_s.upcase,
+            :method => method,
             :params => parameters,
 
             "SERVER_NAME"     => host,
@@ -279,7 +263,7 @@ module ActionController
               string << "#{name}=#{value}; "
             }
           }
-          env = ActionDispatch::Test::MockRequest.env_for(@path, opts)
+          env = Rack::MockRequest.env_for(path, opts)
 
           (headers || {}).each do |key, value|
             key = key.to_s.upcase.gsub(/-/, "_")
@@ -289,30 +273,20 @@ module ActionController
 
           app = Rack::Lint.new(@app)
           status, headers, body = app.call(env)
-          response = ::Rack::MockResponse.new(status, headers, body)
+          mock_response = ::Rack::MockResponse.new(status, headers, body)
 
           @request_count += 1
-          @request = Request.new(env)
-
-          @response = Response.new
-          @response.status  = @status  = response.status
-          @response.headers = @headers = response.headers
-          @response.body    = @body    = response.body
+          @request  = ActionDispatch::Request.new(env)
+          @response = ActionDispatch::TestResponse.from_response(mock_response)
 
-          @status_message = ActionDispatch::StatusCodes::STATUS_CODES[@status]
           @cookies.merge!(@response.cookies)
           @html_document = nil
 
-          # Decorate the response with the standard behavior of the
-          # TestResponse so that things like assert_response can be
-          # used in integration tests.
-          @response.extend(TestResponseBehavior)
-
           if @controller = ActionController::Base.last_instantiation
             @controller.send(:set_test_assigns)
           end
 
-          return @status
+          return response.status
         end
 
         # Get a temporary URL writer object
@@ -335,24 +309,21 @@ module ActionController
       def self.included(base)
         base.extend(ClassMethods)
         base.class_eval do
-          class << self
-            alias_method_chain :new, :capture
-          end
+          alias_method_chain :initialize, :capture
         end
       end
 
+      def initialize_with_capture(*args)
+        initialize_without_capture
+        self.class.last_instantiation ||= self
+      end
+
       module ClassMethods #:nodoc:
         mattr_accessor :last_instantiation
 
         def clear_last_instantiation!
           self.last_instantiation = nil
         end
-
-        def new_with_capture(*args)
-          controller = new_without_capture(*args)
-          self.last_instantiation ||= controller
-          controller
-        end
       end
     end
 
@@ -508,54 +479,5 @@ module ActionController
   #   end
   class IntegrationTest < ActiveSupport::TestCase
     include Integration::Runner
-
-    # Work around a bug in test/unit caused by the default test being named
-    # as a symbol (:default_test), which causes regex test filters
-    # (like "ruby test.rb -n /foo/") to fail because =~ doesn't work on
-    # symbols.
-    def initialize(name) #:nodoc:
-      super(name.to_s)
-    end
-
-    # Work around test/unit's requirement that every subclass of TestCase have
-    # at least one test method. Note that this implementation extends to all
-    # subclasses, as well, so subclasses of IntegrationTest may also exist
-    # without any test methods.
-    def run(*args) #:nodoc:
-      return if @method_name == "default_test"
-      super
-    end
-
-    # Because of how use_instantiated_fixtures and use_transactional_fixtures
-    # are defined, we need to treat them as special cases. Otherwise, users
-    # would potentially have to set their values for both Test::Unit::TestCase
-    # ActionController::IntegrationTest, since by the time the value is set on
-    # TestCase, IntegrationTest has already been defined and cannot inherit
-    # changes to those variables. So, we make those two attributes
-    # copy-on-write.
-
-    class << self
-      def use_transactional_fixtures=(flag) #:nodoc:
-        @_use_transactional_fixtures = true
-        @use_transactional_fixtures = flag
-      end
-
-      def use_instantiated_fixtures=(flag) #:nodoc:
-        @_use_instantiated_fixtures = true
-        @use_instantiated_fixtures = flag
-      end
-
-      def use_transactional_fixtures #:nodoc:
-        @_use_transactional_fixtures ?
-          @use_transactional_fixtures :
-          superclass.use_transactional_fixtures
-      end
-
-      def use_instantiated_fixtures #:nodoc:
-        @_use_instantiated_fixtures ?
-          @use_instantiated_fixtures :
-          superclass.use_instantiated_fixtures
-      end
-    end
   end
 end
diff --git a/actionpack/lib/action_controller/testing/process.rb b/actionpack/lib/action_controller/testing/process.rb
index 16a8f66bc4..8f4358c33e 100644
--- a/actionpack/lib/action_controller/testing/process.rb
+++ b/actionpack/lib/action_controller/testing/process.rb
@@ -1,90 +1,13 @@
 require 'rack/session/abstract/id'
+require 'active_support/core_ext/object/conversions'
 
 module ActionController #:nodoc:
-  class TestRequest < ActionDispatch::Request #:nodoc:
-    attr_accessor :cookies
-    attr_accessor :query_parameters, :path
-    attr_accessor :host
-
-    def self.new(env = {})
-      super
-    end
-
+  class TestRequest < ActionDispatch::TestRequest #:nodoc:
     def initialize(env = {})
-      super(Rack::MockRequest.env_for("/").merge(env))
+      super
 
-      @query_parameters   = {}
       self.session = TestSession.new
       self.session_options = TestSession::DEFAULT_OPTIONS.merge(:id => ActiveSupport::SecureRandom.hex(16))
-
-      initialize_default_values
-      initialize_containers
-    end
-
-    # Wraps raw_post in a StringIO.
-    def body_stream #:nodoc:
-      StringIO.new(raw_post)
-    end
-
-    # Either the RAW_POST_DATA environment variable or the URL-encoded request
-    # parameters.
-    def raw_post
-      @env['RAW_POST_DATA'] ||= begin
-        data = url_encoded_request_parameters
-        data.force_encoding(Encoding::BINARY) if data.respond_to?(:force_encoding)
-        data
-      end
-    end
-
-    def port=(number)
-      @env["SERVER_PORT"] = number.to_i
-    end
-
-    def action=(action_name)
-      @query_parameters.update({ "action" => action_name })
-      @parameters = nil
-    end
-
-    # Used to check AbstractRequest's request_uri functionality.
-    # Disables the use of @path and @request_uri so superclass can handle those.
-    def set_REQUEST_URI(value)
-      @env["REQUEST_URI"] = value
-      @request_uri = nil
-      @path = nil
-    end
-
-    def request_uri=(uri)
-      @request_uri = uri
-      @path = uri.split("?").first
-    end
-
-    def request_method=(method)
-      @request_method = method
-    end
-
-    def accept=(mime_types)
-      @env["HTTP_ACCEPT"] = Array(mime_types).collect { |mime_types| mime_types.to_s }.join(",")
-      @accepts = nil
-    end
-
-    def if_modified_since=(last_modified)
-      @env["HTTP_IF_MODIFIED_SINCE"] = last_modified
-    end
-
-    def if_none_match=(etag)
-      @env["HTTP_IF_NONE_MATCH"] = etag
-    end
-
-    def remote_addr=(addr)
-      @env['REMOTE_ADDR'] = addr
-    end
-
-    def request_uri(*args)
-      @request_uri || super()
-    end
-
-    def path(*args)
-      @path || super()
     end
 
     def assign_parameters(controller_path, action, parameters)
@@ -104,129 +27,36 @@ module ActionController #:nodoc:
           path_parameters[key.to_s] = value
         end
       end
-      raw_post # populate env['RAW_POST_DATA']
-      @parameters = nil # reset TestRequest#parameters to use the new path_parameters
-    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
-    end
-
-    def user_agent=(user_agent)
-      @env['HTTP_USER_AGENT'] = user_agent
-    end
+      params = self.request_parameters.dup
 
-    private
-      def initialize_containers
-        @cookies = {}
+      %w(controller action only_path).each do |k|
+        params.delete(k)
+        params.delete(k.to_sym)
       end
 
-      def initialize_default_values
-        @host                    = "test.host"
-        @request_uri             = "/"
-        @env['HTTP_USER_AGENT']  = "Rails Testing"
-        @env['REMOTE_ADDR']      = "0.0.0.0"
-        @env["SERVER_PORT"]      = 80
-        @env['REQUEST_METHOD']   = "GET"
-      end
-
-      def url_encoded_request_parameters
-        params = self.request_parameters.dup
-
-        %w(controller action only_path).each do |k|
-          params.delete(k)
-          params.delete(k.to_sym)
-        end
-
-        params.to_query
-      end
-  end
-
-  # A refactoring of TestResponse to allow the same behavior to be applied
-  # to the "real" CgiResponse class in integration tests.
-  module TestResponseBehavior #:nodoc:
-    def redirect_url_match?(pattern)
-      ::ActiveSupport::Deprecation.warn("response.redirect_url_match? is deprecated. Use assert_match(/foo/, response.redirect_url) instead", caller)
-      return false if redirect_url.nil?
-      p = Regexp.new(pattern) if pattern.class == String
-      p = pattern if pattern.class == Regexp
-      return false if p.nil?
-      p.match(redirect_url) != nil
-    end
-
-    # Returns the template of the file which was used to
-    # render this response (or nil)
-    def rendered
-      ActiveSupport::Deprecation.warn("response.rendered has been deprecated. Use tempate.rendered instead", caller)
-      @template.instance_variable_get(:@_rendered)
-    end
-
-    # A shortcut to the flash. Returns an empty hash if no session flash exists.
-    def flash
-      request.session['flash'] || {}
-    end
-
-    # Do we have a flash?
-    def has_flash?
-      !flash.empty?
-    end
-
-    # Do we have a flash that has contents?
-    def has_flash_with_contents?
-      !flash.empty?
-    end
-
-    # Does the specified flash object exist?
-    def has_flash_object?(name=nil)
-      !flash[name].nil?
+      data = params.to_query
+      @env['CONTENT_LENGTH'] = data.length.to_s
+      @env['rack.input'] = StringIO.new(data)
     end
 
-    # Does the specified object exist in the session?
-    def has_session_object?(name=nil)
-      !session[name].nil?
-    end
-
-    # A shortcut to the template.assigns
-    def template_objects
-      ActiveSupport::Deprecation.warn("response.template_objects has been deprecated. Use tempate.assigns instead", caller)
-      @template.assigns || {}
-    end
-
-    # Does the specified template object exist?
-    def has_template_object?(name=nil)
-      ActiveSupport::Deprecation.warn("response.has_template_object? has been deprecated. Use tempate.assigns[name].nil? instead", caller)
-      !template_objects[name].nil?
-    end
-
-    # Returns binary content (downloadable file), converted to a String
-    def binary_content
-      raise "Response body is not a Proc: #{body_parts.inspect}" unless body_parts.kind_of?(Proc)
-      require 'stringio'
-
-      sio = StringIO.new
-      body_parts.call(self, sio)
-
-      sio.rewind
-      sio.read
+    def recycle!
+      @env.delete_if { |k, v| k =~ /^(action_dispatch|rack)\.request/ }
+      @env.delete_if { |k, v| k =~ /^action_dispatch\.rescue/ }
+      @env['action_dispatch.request.query_parameters'] = {}
     end
   end
 
-  # Integration test methods such as ActionController::Integration::Session#get
-  # and ActionController::Integration::Session#post return objects of class
-  # TestResponse, which represent the HTTP response results of the requested
-  # controller actions.
-  #
-  # See Response for more information on controller response objects.
-  class TestResponse < ActionDispatch::Response
-    include TestResponseBehavior
-
+  class TestResponse < ActionDispatch::TestResponse
     def recycle!
-      body_parts.clear
-      headers.delete('ETag')
-      headers.delete('Last-Modified')
+      @status = 200
+      @header = Rack::Utils::HeaderHash.new(DEFAULT_HEADERS)
+      @writer = lambda { |x| @body << x }
+      @block = nil
+      @length = 0
+      @body = []
+
+      @request = @template = nil
     end
   end
 
@@ -250,7 +80,7 @@ module ActionController #:nodoc:
   #
   # Pass a true third parameter to ensure the uploaded file is opened in binary mode (only required for Windows):
   #   post :change_avatar, :avatar => ActionController::TestUploadedFile.new(ActionController::TestCase.fixture_path + '/files/spongebob.png', 'image/png', :binary)
-  TestUploadedFile = ActionDispatch::Test::UploadedFile
+  TestUploadedFile = Rack::Utils::Multipart::UploadedFile
 
   module TestProcess
     def self.included(base)
@@ -293,9 +123,7 @@ module ActionController #:nodoc:
       @response.recycle!
 
       @html_document = nil
-      @request.env['REQUEST_METHOD'] = http_method
-
-      @request.action = action.to_s
+      @request.request_method = http_method
 
       parameters ||= {}
       @request.assign_parameters(@controller.class.controller_path, action.to_s, parameters)
@@ -304,8 +132,23 @@ module ActionController #:nodoc:
       @request.session["flash"] = ActionController::Flash::FlashHash.new.update(flash) if flash
       build_request_uri(action, parameters)
 
+      @request.env["action_controller.rescue.request"] = @request
+      @request.env["action_controller.rescue.response"] = @response
+
       Base.class_eval { include ProcessWithTest } unless Base < ProcessWithTest
-      @controller.process_with_test(@request, @response)
+
+      env = @request.env
+      app = @controller
+
+      # TODO: Enable Lint
+      # app = Rack::Lint.new(app)
+
+      status, headers, body = app.action(action, env)
+      response = Rack::MockResponse.new(status, headers, body)
+
+      @response.request, @response.template = @request, @controller.template
+      @response.status, @response.headers, @response.body = response.status, response.headers, response.body
+      @response
     end
 
     def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil)
@@ -319,11 +162,13 @@ module ActionController #:nodoc:
     alias xhr :xml_http_request
 
     def assigns(key = nil)
-      if key.nil?
-        @controller.template.assigns
-      else
-        @controller.template.assigns[key.to_s]
+      assigns = {}
+      @controller.instance_variable_names.each do |ivar|
+        next if ActionController::Base.protected_instance_variables.include?(ivar)
+        assigns[ivar[1..-1]] = @controller.instance_variable_get(ivar)
       end
+      
+      key.nil? ? assigns : assigns[key.to_s]
     end
 
     def session
@@ -331,7 +176,7 @@ module ActionController #:nodoc:
     end
 
     def flash
-      @response.flash
+      @request.flash
     end
 
     def cookies
@@ -348,7 +193,7 @@ module ActionController #:nodoc:
         options.update(:only_path => true, :action => action)
 
         url = ActionController::UrlRewriter.new(@request, parameters)
-        @request.set_REQUEST_URI(url.rewrite(options))
+        @request.request_uri = url.rewrite(options)
       end
     end
 
@@ -421,11 +266,14 @@ module ActionController #:nodoc:
 
   module ProcessWithTest #:nodoc:
     def self.included(base)
-      base.class_eval { attr_reader :assigns }
+      base.class_eval {
+        attr_reader :assigns
+        alias_method_chain :process, :test
+      }
     end
 
     def process_with_test(*args)
-      process(*args).tap { set_test_assigns }
+      process_without_test(*args).tap { set_test_assigns }
     end
 
     private
diff --git a/actionpack/lib/action_controller/testing/process2.rb b/actionpack/lib/action_controller/testing/process2.rb
new file mode 100644
index 0000000000..e9a79369b9
--- /dev/null
+++ b/actionpack/lib/action_controller/testing/process2.rb
@@ -0,0 +1,70 @@
+require "action_controller/testing/process"
+
+module ActionController
+  module TestProcess
+    
+    # Executes a request simulating GET HTTP method and set/volley the response
+    def get(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "GET")
+    end
+
+    # Executes a request simulating POST HTTP method and set/volley the response
+    def post(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "POST")
+    end
+
+    # Executes a request simulating PUT HTTP method and set/volley the response
+    def put(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "PUT")
+    end
+
+    # Executes a request simulating DELETE HTTP method and set/volley the response
+    def delete(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "DELETE")
+    end
+
+    # Executes a request simulating HEAD HTTP method and set/volley the response
+    def head(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "HEAD")
+    end
+
+    def process(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
+      # Sanity check for required instance variables so we can give an
+      # understandable error message.
+      %w(@controller @request @response).each do |iv_name|
+        if !(instance_variable_names.include?(iv_name) || instance_variable_names.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
+          raise "#{iv_name} is nil: make sure you set it in your test's setup method."
+        end
+      end
+
+      @request.recycle!
+      @response.recycle!
+      @controller.response_body = nil
+
+      @html_document = nil
+      @request.env['REQUEST_METHOD'] = http_method
+
+      parameters ||= {}
+      @request.assign_parameters(@controller.class.controller_path, action.to_s, parameters)
+
+      @request.session = ActionController::TestSession.new(session) unless session.nil?
+      @request.session["flash"] = ActionController::Flash::FlashHash.new.update(flash) if flash
+      build_request_uri(action, parameters)
+      @controller.request = @request
+      @controller.params.merge!(parameters)
+      # Base.class_eval { include ProcessWithTest } unless Base < ProcessWithTest
+      @controller.process_with_test(@request, @response)
+    end
+    
+    def build_request_uri(action, parameters)
+      unless @request.env['REQUEST_URI']
+        options = @controller.__send__(:rewrite_options, parameters)
+        options.update(:only_path => true, :action => action)
+
+        url = ActionController::UrlRewriter.new(@request, parameters)
+        @request.request_uri = url.rewrite(options)
+      end
+    end      
+      
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/testing/test_case.rb b/actionpack/lib/action_controller/testing/test_case.rb
index beea174766..a11755b517 100644
--- a/actionpack/lib/action_controller/testing/test_case.rb
+++ b/actionpack/lib/action_controller/testing/test_case.rb
@@ -105,20 +105,7 @@ module ActionController
   class TestCase < ActiveSupport::TestCase
     include TestProcess
 
-    module Assertions
-      %w(response selector tag dom routing model).each do |kind|
-        include ActionController::Assertions.const_get("#{kind.camelize}Assertions")
-      end
-
-      def clean_backtrace(&block)
-        yield
-      rescue ActiveSupport::TestCase::Assertion => error
-        framework_path = Regexp.new(File.expand_path("#{File.dirname(__FILE__)}/assertions"))
-        error.backtrace.reject! { |line| File.expand_path(line) =~ framework_path }
-        raise
-      end
-    end
-    include Assertions
+    include ActionDispatch::Assertions
 
     # When the request.remote_addr remains the default for testing, which is 0.0.0.0, the exception is simply raised inline
     # (bystepping the regular exception handling from rescue_action). If the request.remote_addr is anything else, the regular
diff --git a/actionpack/lib/action_dispatch.rb b/actionpack/lib/action_dispatch.rb
index 4f65dcadee..27d229835a 100644
--- a/actionpack/lib/action_dispatch.rb
+++ b/actionpack/lib/action_dispatch.rb
@@ -21,18 +21,16 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift activesupport_path if File.directory?(activesupport_path)
+require 'active_support'
+
 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
+  gem 'rack', '~> 1.1.pre'
+rescue Gem::LoadError
+  $:.unshift "#{File.dirname(__FILE__)}/action_dispatch/vendor/rack-1.1.pre"
 end
-require 'active_support/core/all'
 
-gem 'rack', '~> 1.0.0'
 require 'rack'
 
 module ActionDispatch
@@ -42,9 +40,14 @@ module ActionDispatch
 
   autoload :Failsafe, 'action_dispatch/middleware/failsafe'
   autoload :ParamsParser, 'action_dispatch/middleware/params_parser'
-  autoload :Reloader, 'action_dispatch/middleware/reloader'
+  autoload :Rescue, 'action_dispatch/middleware/rescue'
+  autoload :ShowExceptions, 'action_dispatch/middleware/show_exceptions'
   autoload :MiddlewareStack, 'action_dispatch/middleware/stack'
 
+  autoload :Assertions, 'action_dispatch/testing/assertions'
+  autoload :TestRequest, 'action_dispatch/testing/test_request'
+  autoload :TestResponse, 'action_dispatch/testing/test_response'
+
   module Http
     autoload :Headers, 'action_dispatch/http/headers'
   end
@@ -54,11 +57,6 @@ module ActionDispatch
     autoload :CookieStore, 'action_dispatch/middleware/session/cookie_store'
     autoload :MemCacheStore, 'action_dispatch/middleware/session/mem_cache_store'
   end
-
-  module Test
-    autoload :UploadedFile, 'action_dispatch/test/uploaded_file'
-    autoload :MockRequest, 'action_dispatch/test/mock'
-  end
 end
 
 autoload :Mime, 'action_dispatch/http/mime_type'
diff --git a/actionpack/lib/action_dispatch/http/mime_type.rb b/actionpack/lib/action_dispatch/http/mime_type.rb
index 02ad7f7d94..dfcf3a558f 100644
--- a/actionpack/lib/action_dispatch/http/mime_type.rb
+++ b/actionpack/lib/action_dispatch/http/mime_type.rb
@@ -1,4 +1,5 @@
 require 'set'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module Mime
   SET              = []
diff --git a/actionpack/lib/action_dispatch/http/request.rb b/actionpack/lib/action_dispatch/http/request.rb
index 2602b344ca..13ff049a97 100755
--- a/actionpack/lib/action_dispatch/http/request.rb
+++ b/actionpack/lib/action_dispatch/http/request.rb
@@ -3,6 +3,7 @@ require 'stringio'
 require 'strscan'
 
 require 'active_support/memoizable'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module ActionDispatch
   class Request < Rack::Request
@@ -31,7 +32,7 @@ module ActionDispatch
     # <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(ActionController::UnknownHttpMethod, "#{super}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
+      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
@@ -85,7 +86,7 @@ module ActionDispatch
     # For backward compatibility, the post \format is extracted from the
     # X-Post-Data-Format HTTP header if present.
     def content_type
-      @content_type ||= begin
+      @env["action_dispatch.request.content_type"] ||= begin
         if @env['CONTENT_TYPE'] =~ /^([^,\;]*)/
           Mime::Type.lookup($1.strip.downcase)
         else
@@ -100,7 +101,7 @@ module ActionDispatch
 
     # Returns the accepted MIME type for the request.
     def accepts
-      @accepts ||= begin
+      @env["action_dispatch.request.accepts"] ||= begin
         header = @env['HTTP_ACCEPT'].to_s.strip
 
         fallback = xhr? ? Mime::JS : Mime::HTML
@@ -160,7 +161,7 @@ module ActionDispatch
     #   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(view_path = [])
-      @format ||=
+      @env["action_dispatch.request.format"] ||=
         if parameters[:format]
                         Mime[parameters[:format]]
         elsif ActionController::Base.use_accept_header && !(accepts == ONLY_ALL)
@@ -171,12 +172,11 @@ module ActionDispatch
     end
 
     def formats
-      @formats = 
-        if ActionController::Base.use_accept_header
-          Array(Mime[parameters[:format]] || accepts)
-        else
-          [format]
-        end
+      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
@@ -192,7 +192,7 @@ module ActionDispatch
     #   end
     def format=(extension)
       parameters[:format] = extension.to_s
-      @format = Mime::Type.lookup_by_extension(parameters[:format])
+      @env["action_dispatch.request.format"] = Mime::Type.lookup_by_extension(parameters[:format])
     end
 
     # Returns a symbolized version of the <tt>:format</tt> parameter of the request.
@@ -328,6 +328,10 @@ EOM
       port == standard_port ? '' : ":#{port}"
     end
 
+    def server_port
+      @env['SERVER_PORT'].to_i
+    end
+
     # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
     # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
     def domain(tld_length = 1)
@@ -348,7 +352,7 @@ EOM
 
     # Returns the query string, accounting for server idiosyncrasies.
     def query_string
-      @env['QUERY_STRING'].present? ? @env['QUERY_STRING'] : (@env['REQUEST_URI'].split('?', 2)[1] || '')
+      @env['QUERY_STRING'].present? ? @env['QUERY_STRING'] : (@env['REQUEST_URI'].to_s.split('?', 2)[1] || '')
     end
 
     # Returns the request URI, accounting for server idiosyncrasies.
@@ -396,18 +400,19 @@ EOM
 
     # Returns both GET and POST \parameters in a single hash.
     def parameters
-      @parameters ||= request_parameters.merge(query_parameters).update(path_parameters).with_indifferent_access
+      @env["action_dispatch.request.parameters"] ||= request_parameters.merge(query_parameters).update(path_parameters).with_indifferent_access
     end
     alias_method :params, :parameters
 
     def path_parameters=(parameters) #:nodoc:
+      @env.delete("action_dispatch.request.symbolized_path_parameters")
+      @env.delete("action_dispatch.request.parameters")
       @env["action_dispatch.request.path_parameters"] = parameters
-      @symbolized_path_parameters = @parameters = nil
     end
 
     # The same as <tt>path_parameters</tt> with explicitly symbolized keys.
     def symbolized_path_parameters
-      @symbolized_path_parameters ||= path_parameters.symbolize_keys
+      @env["action_dispatch.request.symbolized_path_parameters"] ||= path_parameters.symbolize_keys
     end
 
     # Returns a hash with the \parameters used to form the \path of the request.
@@ -437,13 +442,13 @@ EOM
 
     # Override Rack's GET method to support indifferent access
     def GET
-      @env["action_controller.request.query_parameters"] ||= normalize_parameters(super)
+      @env["action_dispatch.request.query_parameters"] ||= normalize_parameters(super)
     end
     alias_method :query_parameters, :GET
 
     # Override Rack's POST method to support indifferent access
     def POST
-      @env["action_controller.request.request_parameters"] ||= normalize_parameters(super)
+      @env["action_dispatch.request.request_parameters"] ||= normalize_parameters(super)
     end
     alias_method :request_parameters, :POST
 
@@ -464,8 +469,8 @@ EOM
       @env['rack.session.options'] = options
     end
 
-    def server_port
-      @env['SERVER_PORT'].to_i
+    def flash
+      session['flash'] || {}
     end
 
     private
diff --git a/actionpack/lib/action_dispatch/http/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index d104dcb8a0..edb522ff49 100644
--- a/actionpack/lib/action_dispatch/http/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -1,4 +1,5 @@
 require 'digest/md5'
+require 'active_support/core_ext/module/delegation'
 
 module ActionDispatch # :nodoc:
   # Represents an HTTP response generated by a controller action. One can use
@@ -34,32 +35,9 @@ module ActionDispatch # :nodoc:
     DEFAULT_HEADERS = { "Cache-Control" => "no-cache" }
     attr_accessor :request
 
-    attr_accessor :redirected_to, :redirected_to_method_params
-
     attr_writer :header
     alias_method :headers=, :header=
 
-    def template
-      ActiveSupport::Deprecation.warn("response.template has been deprecated. Use controller.template instead", caller)
-      @template
-    end
-    attr_writer :template
-
-    def session
-      ActiveSupport::Deprecation.warn("response.session has been deprecated. Use request.session instead", caller)
-      @request.session
-    end
-
-    def assigns
-      ActiveSupport::Deprecation.warn("response.assigns has been deprecated. Use controller.assigns instead", caller)
-      @template.controller.assigns
-    end
-
-    def layout
-      ActiveSupport::Deprecation.warn("response.layout has been deprecated. Use template.layout instead", caller)
-      @template.layout
-    end
-
     delegate :default_charset, :to => 'ActionController::Base'
 
     def initialize
@@ -80,33 +58,7 @@ module ActionDispatch # :nodoc:
     def message
       status.to_s.split(' ',2)[1] || StatusCodes::STATUS_CODES[response_code]
     end
-
-    # Was the response successful?
-    def success?
-      (200..299).include?(response_code)
-    end
-
-    # Was the URL not found?
-    def missing?
-      response_code == 404
-    end
-
-    # Were we redirected?
-    def redirect?
-      (300..399).include?(response_code)
-    end
-
-    # Was there a server-side error?
-    def error?
-      (500..599).include?(response_code)
-    end
-
-    alias_method :server_error?, :error?
-
-    # Was there a client client?
-    def client_error?
-      (400..499).include?(response_code)
-    end
+    alias_method :status_message, :message
 
     def body
       str = ''
@@ -205,12 +157,6 @@ module ActionDispatch # :nodoc:
       end
     end
 
-    def redirect(url, status)
-      self.status = status
-      self.location = url.gsub(/[\r\n]/, '')
-      self.body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"
-    end
-
     def sending_file?
       headers["Content-Transfer-Encoding"] == "binary"
     end
@@ -234,7 +180,7 @@ module ActionDispatch # :nodoc:
         @writer = lambda { |x| callback.call(x) }
         @body.call(self, self)
       else
-        @body.each(&callback)
+        @body.each { |part| callback.call(part.to_s) }
       end
 
       @writer = callback
diff --git a/actionpack/lib/action_dispatch/http/status_codes.rb b/actionpack/lib/action_dispatch/http/status_codes.rb
index 830de2a6db..5bac842ec1 100644
--- a/actionpack/lib/action_dispatch/http/status_codes.rb
+++ b/actionpack/lib/action_dispatch/http/status_codes.rb
@@ -1,3 +1,5 @@
+require 'active_support/inflector'
+
 module ActionDispatch
   module StatusCodes #:nodoc:
     STATUS_CODES = Rack::Utils::HTTP_STATUS_CODES.merge({
@@ -16,7 +18,7 @@ module ActionDispatch
     # :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[ActiveSupport::Inflector.underscore(message.gsub(/ /, "")).to_sym] = code
       hash
     }.freeze
 
@@ -37,4 +39,4 @@ module ActionDispatch
         end
       end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_dispatch/middleware/params_parser.rb b/actionpack/lib/action_dispatch/middleware/params_parser.rb
index abaee2829e..58d527a6e7 100644
--- a/actionpack/lib/action_dispatch/middleware/params_parser.rb
+++ b/actionpack/lib/action_dispatch/middleware/params_parser.rb
@@ -11,7 +11,7 @@ module ActionDispatch
 
     def call(env)
       if params = parse_formatted_parameters(env)
-        env["action_controller.request.request_parameters"] = params
+        env["action_dispatch.request.request_parameters"] = params
       end
 
       @app.call(env)
diff --git a/actionpack/lib/action_dispatch/middleware/reloader.rb b/actionpack/lib/action_dispatch/middleware/reloader.rb
deleted file mode 100644
index 67313e30e4..0000000000
--- a/actionpack/lib/action_dispatch/middleware/reloader.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-module ActionDispatch
-  class Reloader
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      ActionController::Dispatcher.reload_application
-      @app.call(env)
-    ensure
-      ActionController::Dispatcher.cleanup_application
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/middleware/rescue.rb b/actionpack/lib/action_dispatch/middleware/rescue.rb
new file mode 100644
index 0000000000..1456825526
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/rescue.rb
@@ -0,0 +1,14 @@
+module ActionDispatch
+  class Rescue
+    def initialize(app, rescuer)
+      @app, @rescuer = app, rescuer
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      env['action_dispatch.rescue.exception'] = exception
+      @rescuer.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
new file mode 100644
index 0000000000..71c1e1b9a9
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
@@ -0,0 +1,144 @@
+module ActionDispatch
+  class ShowExceptions
+    include StatusCodes
+
+    LOCALHOST = '127.0.0.1'.freeze
+
+    DEFAULT_RESCUE_RESPONSE = :internal_server_error
+    DEFAULT_RESCUE_RESPONSES = {
+      'ActionController::RoutingError'             => :not_found,
+      'ActionController::UnknownAction'            => :not_found,
+      'ActiveRecord::RecordNotFound'               => :not_found,
+      'ActiveRecord::StaleObjectError'             => :conflict,
+      'ActiveRecord::RecordInvalid'                => :unprocessable_entity,
+      'ActiveRecord::RecordNotSaved'               => :unprocessable_entity,
+      'ActionController::MethodNotAllowed'         => :method_not_allowed,
+      'ActionController::NotImplemented'           => :not_implemented,
+      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
+    }
+
+    DEFAULT_RESCUE_TEMPLATE = 'diagnostics'
+    DEFAULT_RESCUE_TEMPLATES = {
+      'ActionView::MissingTemplate'       => 'missing_template',
+      'ActionController::RoutingError'    => 'routing_error',
+      'ActionController::UnknownAction'   => 'unknown_action',
+      'ActionView::TemplateError'         => 'template_error'
+    }
+
+    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
+
+    cattr_accessor :rescue_responses
+    @@rescue_responses = Hash.new(DEFAULT_RESCUE_RESPONSE)
+    @@rescue_responses.update DEFAULT_RESCUE_RESPONSES
+
+    cattr_accessor :rescue_templates
+    @@rescue_templates = Hash.new(DEFAULT_RESCUE_TEMPLATE)
+    @@rescue_templates.update DEFAULT_RESCUE_TEMPLATES
+
+    def initialize(app, consider_all_requests_local = false)
+      @app = app
+      @consider_all_requests_local = consider_all_requests_local
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      raise exception if env['rack.test']
+
+      log_error(exception) if logger
+
+      request = Request.new(env)
+      if @consider_all_requests_local || local_request?(request)
+        rescue_action_locally(request, exception)
+      else
+        rescue_action_in_public(exception)
+      end
+    end
+
+    private
+      # Render detailed diagnostics for unhandled exceptions rescued from
+      # a controller action.
+      def rescue_action_locally(request, exception)
+        template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
+          :template => template,
+          :request => request,
+          :exception => exception
+        )
+        file = "rescues/#{@@rescue_templates[exception.class.name]}.erb"
+        body = template.render(:file => file, :layout => 'rescues/layout.erb')
+
+        headers = {'Content-Type' => 'text/html', 'Content-Length' => body.length.to_s}
+        status = status_code(exception)
+
+        [status, headers, body]
+      end
+
+      # Attempts to render a static error page based on the
+      # <tt>status_code</tt> thrown, or just return headers if no such file
+      # exists. At first, it will try to render a localized static page.
+      # For example, if a 500 error is being handled Rails and locale is :da,
+      # it will first attempt to render the file at <tt>public/500.da.html</tt>
+      # then attempt to render <tt>public/500.html</tt>. If none of them exist,
+      # the body of the response will be left empty.
+      def rescue_action_in_public(exception)
+        status = status_code(exception)
+        locale_path = "#{public_path}/#{status}.#{I18n.locale}.html" if I18n.locale
+        path = "#{public_path}/#{status}.html"
+
+        if locale_path && File.exist?(locale_path)
+          render_public_file(status, locale_path)
+        elsif File.exist?(path)
+          render_public_file(status, path)
+        else
+          [status, {'Content-Type' => 'text/html', 'Content-Length' => '0'}, []]
+        end
+      end
+
+      # True if the request came from localhost, 127.0.0.1.
+      def local_request?(request)
+        request.remote_addr == LOCALHOST && request.remote_ip == LOCALHOST
+      end
+
+      def render_public_file(status, path)
+        body = File.read(path)
+        [status, {'Content-Type' => 'text/html', 'Content-Length' => body.length.to_s}, body]
+      end
+
+      def status_code(exception)
+        interpret_status(@@rescue_responses[exception.class.name]).to_i
+      end
+
+      def public_path
+        if defined?(Rails)
+          Rails.public_path
+        else
+          "public"
+        end
+      end
+
+      def log_error(exception) #:doc:
+        ActiveSupport::Deprecation.silence do
+          if ActionView::TemplateError === exception
+            logger.fatal(exception.to_s)
+          else
+            logger.fatal(
+              "\n#{exception.class} (#{exception.message}):\n  " +
+              clean_backtrace(exception).join("\n  ") + "\n\n"
+            )
+          end
+        end
+      end
+
+      def clean_backtrace(exception)
+        defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
+          Rails.backtrace_cleaner.clean(exception.backtrace) :
+          exception.backtrace
+      end
+
+      def logger
+        if defined?(Rails.logger)
+          Rails.logger
+        end
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/stack.rb b/actionpack/lib/action_dispatch/middleware/stack.rb
index ee5f28d5cb..ade2d6f05e 100644
--- a/actionpack/lib/action_dispatch/middleware/stack.rb
+++ b/actionpack/lib/action_dispatch/middleware/stack.rb
@@ -34,8 +34,6 @@ module ActionDispatch
         else
           @klass.to_s.constantize
         end
-      rescue NameError
-        @klass
       end
 
       def active?
@@ -61,7 +59,7 @@ module ActionDispatch
 
       def inspect
         str = klass.to_s
-        args.each { |arg| str += ", #{arg.inspect}" }
+        args.each { |arg| str += ", #{build_args.inspect}" }
         str
       end
 
@@ -74,7 +72,6 @@ module ActionDispatch
       end
 
       private
-
         def build_args
           Array(args).map { |arg| arg.respond_to?(:call) ? arg.call : arg }
         end
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/_request_and_response.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
index 64b34650b1..5224403dab 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/_request_and_response.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
@@ -6,7 +6,7 @@
 <% end %>
 
 <%
-  clean_params = request.parameters.clone
+  clean_params = @request.parameters.clone
   clean_params.delete("action")
   clean_params.delete("controller")
 
@@ -17,8 +17,8 @@
 <p><b>Parameters</b>: <pre><%=h request_dump %></pre></p>
 
 <p><a href="#" onclick="document.getElementById('session_dump').style.display='block'; return false;">Show session dump</a></p>
-<div id="session_dump" style="display:none"><%= debug(request.session.instance_variable_get("@data")) %></div>
+<div id="session_dump" style="display:none"><%= debug(@request.session.instance_variable_get("@data")) %></div>
 
 
 <h2 style="margin-top: 30px">Response</h2>
-<p><b>Headers</b>: <pre><%=h response ? response.headers.inspect.gsub(',', ",\n") : 'None' %></pre></p>
+<p><b>Headers</b>: <pre><%=h @response ? @response.headers.inspect.gsub(',', ",\n") : 'None' %></pre></p>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/_trace.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
index bb2d8375bd..bb2d8375bd 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/_trace.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
new file mode 100644
index 0000000000..693e56270a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
@@ -0,0 +1,10 @@
+<h1>
+  <%=h @exception.class.to_s %>
+  <% if @request.parameters['controller'] %>
+    in <%=h @request.parameters['controller'].humanize %>Controller<% if @request.parameters['action'] %>#<%=h @request.parameters['action'] %><% end %>
+  <% end %>
+</h1>
+<pre><%=h @exception.clean_message %></pre>
+
+<%= render :file => "rescues/_trace.erb" %>
+<%= render :file => "rescues/_request_and_response.erb" %>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/layout.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
index 4a04742e40..6c32fb17b8 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/layout.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
@@ -23,7 +23,7 @@
 </head>
 <body>
 
-<%= @contents %>
+<%= yield %>
 
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/missing_template.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.erb
index dbfdf76947..dbfdf76947 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/missing_template.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.erb
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/routing_error.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
index ccfa858cce..ccfa858cce 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/routing_error.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/template_error.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
index 2e34e03bd5..02fa18211d 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/template_error.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
@@ -1,6 +1,6 @@
 <h1>
   <%=h @exception.original_exception.class.to_s %> in
-  <%=h request.parameters["controller"].capitalize if request.parameters["controller"]%>#<%=h request.parameters["action"] %>
+  <%=h @request.parameters["controller"].capitalize if @request.parameters["controller"]%>#<%=h @request.parameters["action"] %>
 </h1>
 
 <p>
@@ -15,7 +15,7 @@
 
 <% @real_exception = @exception
    @exception = @exception.original_exception || @exception %>
-<%= render :file => @rescues_path["rescues/_trace.erb"] %>
+<%= render :file => "rescues/_trace.erb" %>
 <% @exception = @real_exception %>
 
-<%= render :file => @rescues_path["rescues/_request_and_response.erb"] %>
+<%= render :file => "rescues/_request_and_response.erb" %>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/unknown_action.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.erb
index 683379da10..683379da10 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/unknown_action.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.erb
diff --git a/actionpack/lib/action_dispatch/test/mock.rb b/actionpack/lib/action_dispatch/test/mock.rb
deleted file mode 100644
index 68e5b108b4..0000000000
--- a/actionpack/lib/action_dispatch/test/mock.rb
+++ /dev/null
@@ -1,115 +0,0 @@
-module ActionDispatch
-  module Test
-    class MockRequest < Rack::MockRequest
-      MULTIPART_BOUNDARY = "----------XnJLe9ZIbbGUYtzPQJ16u1"
-
-      class << self
-        def env_for(path, opts)
-          method = (opts[:method] || opts["REQUEST_METHOD"]).to_s.upcase
-          opts[:method] = opts["REQUEST_METHOD"] = method
-
-          path = "/#{path}" unless path[0] == ?/
-          uri = URI.parse(path)
-          uri.host ||= "example.org"
-
-          if URI::HTTPS === uri
-            opts.update("SERVER_PORT" => "443", "HTTPS" => "on")
-          end
-
-          if method == "POST" && !opts.has_key?(:input)
-            opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
-
-            multipart = opts[:params].respond_to?(:any?) && opts[:params].any? { |k, v| UploadedFile === v }
-            if multipart
-              opts[:input] = multipart_body(opts.delete(:params))
-              opts["CONTENT_LENGTH"] ||= opts[:input].length.to_s
-              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{MULTIPART_BOUNDARY}"
-            else
-              params = opts.delete(:params)
-              opts[:input] = case params
-                  when Hash then requestify(params)
-                  when nil  then ""
-                  else params
-                end
-            end
-          end
-
-          params = opts[:params] || {}
-          if params.is_a?(String)
-            if method == "GET"
-              uri.query = params
-            else
-              opts[:input] = params
-            end
-          else
-            params.stringify_keys!
-            params.update(::Rack::Utils.parse_query(uri.query))
-            uri.query = requestify(params)
-          end
-
-          ::Rack::MockRequest.env_for(uri.to_s, opts)
-        end
-
-        private
-          def requestify(value, prefix = nil)
-            case value
-            when Array
-              value.map do |v|
-                requestify(v, "#{prefix}[]")
-              end.join("&")
-            when Hash
-              value.map do |k, v|
-                requestify(v, prefix ? "#{prefix}[#{::Rack::Utils.escape(k)}]" : ::Rack::Utils.escape(k))
-              end.join("&")
-            else
-              "#{prefix}=#{::Rack::Utils.escape(value)}"
-            end
-          end
-
-          def multipart_requestify(params, first=true)
-            p = Hash.new
-
-            params.each do |key, value|
-              k = first ? key.to_s : "[#{key}]"
-
-              if Hash === value
-                multipart_requestify(value, false).each do |subkey, subvalue|
-                  p[k + subkey] = subvalue
-                end
-              else
-                p[k] = value
-              end
-            end
-
-            return p
-          end
-
-          def multipart_body(params)
-            multipart_requestify(params).map do |key, value|
-              if value.respond_to?(:original_filename)
-                ::File.open(value.path, "rb") do |f|
-                  f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
-
-                  <<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{key}"; filename="#{::Rack::Utils.escape(value.original_filename)}"\r
-Content-Type: #{value.content_type}\r
-Content-Length: #{::File.stat(value.path).size}\r
-\r
-#{f.read}\r
-EOF
-            end
-          else
-<<-EOF
---#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{key}"\r
-\r
-#{value}\r
-EOF
-              end
-            end.join("")+"--#{MULTIPART_BOUNDARY}--\r"
-          end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/test/uploaded_file.rb b/actionpack/lib/action_dispatch/test/uploaded_file.rb
deleted file mode 100644
index 0ac7db4863..0000000000
--- a/actionpack/lib/action_dispatch/test/uploaded_file.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-require "tempfile"
-
-module ActionDispatch
-  module Test
-    class UploadedFile
-      # The filename, *not* including the path, of the "uploaded" file
-      attr_reader :original_filename
-
-      # The content type of the "uploaded" file
-      attr_accessor :content_type
-
-      def initialize(path, content_type = "text/plain", binary = false)
-        raise "#{path} file does not exist" unless ::File.exist?(path)
-        @content_type = content_type
-        @original_filename = ::File.basename(path)
-        @tempfile = Tempfile.new(@original_filename)
-        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
-        @tempfile.binmode if binary
-        FileUtils.copy_file(path, @tempfile.path)
-      end
-
-      def path
-        @tempfile.path
-      end
-
-      alias_method :local_path, :path
-
-      def method_missing(method_name, *args, &block) #:nodoc:
-        @tempfile.__send__(method_name, *args, &block)
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/testing/assertions.rb b/actionpack/lib/action_dispatch/testing/assertions.rb
new file mode 100644
index 0000000000..96f08f2355
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/assertions.rb
@@ -0,0 +1,8 @@
+module ActionDispatch
+  module Assertions
+    %w(response selector tag dom routing model).each do |kind|
+      require "action_dispatch/testing/assertions/#{kind}"
+      include const_get("#{kind.camelize}Assertions")
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/testing/assertions/dom.rb b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
index 5ffe5f1883..9a917f704a 100644
--- a/actionpack/lib/action_controller/testing/assertions/dom.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     module DomAssertions
       # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
@@ -9,13 +9,11 @@ module ActionController
       #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
       #
       def assert_dom_equal(expected, actual, message = "")
-        clean_backtrace do
-          expected_dom = HTML::Document.new(expected).root
-          actual_dom   = HTML::Document.new(actual).root
-          full_message = build_message(message, "<?> expected to be == to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        full_message = build_message(message, "<?> expected to be == to\n<?>.", expected_dom.to_s, actual_dom.to_s)
 
-          assert_block(full_message) { expected_dom == actual_dom }
-        end
+        assert_block(full_message) { expected_dom == actual_dom }
       end
       
       # The negated form of +assert_dom_equivalent+.
@@ -26,13 +24,11 @@ module ActionController
       #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
       #
       def assert_dom_not_equal(expected, actual, message = "")
-        clean_backtrace do
-          expected_dom = HTML::Document.new(expected).root
-          actual_dom   = HTML::Document.new(actual).root
-          full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
 
-          assert_block(full_message) { expected_dom != actual_dom }
-        end
+        assert_block(full_message) { expected_dom != actual_dom }
       end
     end
   end
diff --git a/actionpack/lib/action_controller/testing/assertions/model.rb b/actionpack/lib/action_dispatch/testing/assertions/model.rb
index 3a7b39b106..46714418c6 100644
--- a/actionpack/lib/action_controller/testing/assertions/model.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/model.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     module ModelAssertions
       # Ensures that the passed record is valid by Active Record standards and
@@ -12,9 +12,7 @@ module ActionController
       #
       def assert_valid(record)
         ::ActiveSupport::Deprecation.warn("assert_valid is deprecated. Use assert record.valid? instead", caller)
-        clean_backtrace do
-          assert record.valid?, record.errors.full_messages.join("\n")
-        end
+        assert record.valid?, record.errors.full_messages.join("\n")
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/testing/assertions/response.rb b/actionpack/lib/action_dispatch/testing/assertions/response.rb
new file mode 100644
index 0000000000..501a7c4dfb
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/assertions/response.rb
@@ -0,0 +1,145 @@
+module ActionDispatch
+  module Assertions
+    # A small suite of assertions that test responses from Rails applications.
+    module ResponseAssertions
+      # Asserts that the response is one of the following types:
+      #
+      # * <tt>:success</tt>   - Status code was 200
+      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
+      # * <tt>:missing</tt>   - Status code was 404
+      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      #
+      # You can also pass an explicit status number like assert_response(501)
+      # or its symbolic equivalent assert_response(:not_implemented).
+      # See ActionDispatch::StatusCodes for a full list.
+      #
+      # ==== Examples
+      #
+      #   # assert that the response was a redirection
+      #   assert_response :redirect
+      #
+      #   # assert that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      #
+      def assert_response(type, message = nil)
+        validate_request!
+
+        if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
+          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 == ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
+          assert_block("") { true } # to count the assertion
+        else
+          assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
+        end
+      end
+
+      # Assert that the redirection options passed in match those of the redirect called in the latest action.
+      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
+      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
+      #
+      # ==== Examples
+      #
+      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to :controller => "weblog", :action => "index"
+      #
+      #   # assert that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      #   # assert that the redirection was to the url for @customer
+      #   assert_redirected_to @customer
+      #
+      def assert_redirected_to(options = {}, message=nil)
+        validate_request!
+
+        assert_response(:redirect, message)
+        return true if options == @response.location
+
+        redirected_to_after_normalisation = normalize_argument_to_redirection(@response.location)
+        options_after_normalisation       = normalize_argument_to_redirection(options)
+
+        if redirected_to_after_normalisation != options_after_normalisation
+          flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
+        end
+      end
+
+      # Asserts that the request was rendered with the appropriate template file or partials
+      #
+      # ==== Examples
+      #
+      #   # assert that the "new" view template was rendered
+      #   assert_template "new"
+      #
+      #   # assert that the "_customer" partial was rendered twice
+      #   assert_template :partial => '_customer', :count => 2
+      #
+      #   # assert that no partials were rendered
+      #   assert_template :partial => false
+      #
+      def assert_template(options = {}, message = nil)
+        validate_request!
+
+        case options
+         when NilClass, String
+          rendered = (@controller.template.rendered[:template] || []).map { |t| t.identifier }
+          msg = build_message(message,
+                  "expecting <?> but rendering with <?>",
+                  options, rendered.join(', '))
+          assert_block(msg) do
+            if options.nil?
+              @controller.template.rendered[:template].blank?
+            else
+              rendered.any? { |t| t.match(options) }
+            end
+          end
+        when Hash
+          if expected_partial = options[:partial]
+            partials = @controller.template.rendered[:partials]
+            if expected_count = options[:count]
+              found = partials.detect { |p, _| p.identifier.match(expected_partial) }
+              actual_count = found.nil? ? 0 : found.second
+              msg = build_message(message,
+                      "expecting ? to be rendered ? time(s) but rendered ? time(s)",
+                       expected_partial, expected_count, actual_count)
+              assert(actual_count == expected_count.to_i, msg)
+            else
+              msg = build_message(message,
+                      "expecting partial <?> but action rendered <?>",
+                      options[:partial], partials.keys)
+              assert(partials.keys.any? { |p| p.identifier.match(expected_partial) }, msg)
+            end
+          else
+            assert @controller.template.rendered[:partials].empty?,
+              "Expected no partials to be rendered"
+          end
+        end
+      end
+
+      private
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+
+        def normalize_argument_to_redirection(fragment)
+          after_routing = @controller.url_for(fragment)
+          if after_routing =~ %r{^\w+://.*}
+            after_routing
+          else
+            # FIXME - this should probably get removed.
+            if after_routing.first != '/'
+              after_routing = '/' + after_routing
+            end
+            @request.protocol + @request.host_with_port + after_routing
+          end
+        end
+
+        def validate_request!
+          unless @request.is_a?(ActionDispatch::Request)
+            raise ArgumentError, "@request must be an ActionDispatch::Request"
+          end
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/testing/assertions/routing.rb b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
index 5101751cea..89d1a49403 100644
--- a/actionpack/lib/action_controller/testing/assertions/routing.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     # Suite of assertions to test routes generated by Rails and the handling of requests made to them.
     module RoutingAssertions
@@ -44,19 +44,17 @@ module ActionController
           request_method = nil
         end
 
-        clean_backtrace do
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
-          request = recognized_request_for(path, request_method)
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        request = recognized_request_for(path, request_method)
 
-          expected_options = expected_options.clone
-          extras.each_key { |key| expected_options.delete key } unless extras.nil?
+        expected_options = expected_options.clone
+        extras.each_key { |key| expected_options.delete key } unless extras.nil?
 
-          expected_options.stringify_keys!
-          routing_diff = expected_options.diff(request.path_parameters)
-          msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
-              request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
-          assert_block(msg) { request.path_parameters == expected_options }
-        end
+        expected_options.stringify_keys!
+        routing_diff = expected_options.diff(request.path_parameters)
+        msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
+            request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
+        assert_block(msg) { request.path_parameters == expected_options }
       end
 
       # Asserts that the provided options can be used to generate the provided path.  This is the inverse of +assert_recognizes+.
@@ -78,21 +76,19 @@ module ActionController
       #   # Asserts that the generated route gives us our custom route
       #   assert_generates "changesets/12", { :controller => 'scm', :action => 'show_diff', :revision => "12" }
       def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
-        clean_backtrace do
-          expected_path = "/#{expected_path}" unless expected_path[0] == ?/
-          # Load routes.rb if it hasn't been loaded.
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        expected_path = "/#{expected_path}" unless expected_path[0] == ?/
+        # Load routes.rb if it hasn't been loaded.
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
 
-          generated_path, extra_keys = ActionController::Routing::Routes.generate_extras(options, defaults)
-          found_extras = options.reject {|k, v| ! extra_keys.include? k}
+        generated_path, extra_keys = ActionController::Routing::Routes.generate_extras(options, defaults)
+        found_extras = options.reject {|k, v| ! extra_keys.include? k}
 
-          msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
-          assert_block(msg) { found_extras == extras }
+        msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
+        assert_block(msg) { found_extras == extras }
 
-          msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
-              expected_path)
-          assert_block(msg) { expected_path == generated_path }
-        end
+        msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
+            expected_path)
+        assert_block(msg) { expected_path == generated_path }
       end
 
       # Asserts that path and options match both ways; in other words, it verifies that <tt>path</tt> generates
diff --git a/actionpack/lib/action_controller/testing/assertions/selector.rb b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
index 0d56ea5ef7..dd75cda6b9 100644
--- a/actionpack/lib/action_controller/testing/assertions/selector.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
@@ -3,7 +3,7 @@
 # Under MIT and/or CC By license.
 #++
 
-module ActionController
+module ActionDispatch
   module Assertions
     unless const_defined?(:NO_STRIP)
       NO_STRIP = %w{pre script style textarea}
diff --git a/actionpack/lib/action_controller/testing/assertions/tag.rb b/actionpack/lib/action_dispatch/testing/assertions/tag.rb
index 80249e0e83..ef6867576e 100644
--- a/actionpack/lib/action_controller/testing/assertions/tag.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/tag.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     # Pair of assertions to testing elements in the HTML output of the response.
     module TagAssertions
@@ -94,11 +94,9 @@ module ActionController
       # that allow optional closing tags (p, li, td). <em>You must explicitly
       # close all of your tags to use these assertions.</em>
       def assert_tag(*opts)
-        clean_backtrace do
-          opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
-          tag = find_tag(opts)
-          assert tag, "expected tag, but no tag found matching #{opts.inspect} in:\n#{@response.body.inspect}"
-        end
+        opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
+        tag = find_tag(opts)
+        assert tag, "expected tag, but no tag found matching #{opts.inspect} in:\n#{@response.body.inspect}"
       end
       
       # Identical to +assert_tag+, but asserts that a matching tag does _not_
@@ -116,11 +114,9 @@ module ActionController
       #   assert_no_tag :tag => "p",
       #              :children => { :count => 1..3, :only => { :tag => "img" } }
       def assert_no_tag(*opts)
-        clean_backtrace do
-          opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
-          tag = find_tag(opts)
-          assert !tag, "expected no tag, but found tag matching #{opts.inspect} in:\n#{@response.body.inspect}"
-        end
+        opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
+        tag = find_tag(opts)
+        assert !tag, "expected no tag, but found tag matching #{opts.inspect} in:\n#{@response.body.inspect}"
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/testing/test_request.rb b/actionpack/lib/action_dispatch/testing/test_request.rb
new file mode 100644
index 0000000000..20288aa7a5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/test_request.rb
@@ -0,0 +1,83 @@
+module ActionDispatch
+  class TestRequest < Request
+    DEFAULT_ENV = Rack::MockRequest.env_for('/')
+
+    def self.new(env = {})
+      super
+    end
+
+    def initialize(env = {})
+      super(DEFAULT_ENV.merge(env))
+
+      self.host        = 'test.host'
+      self.remote_addr = '0.0.0.0'
+      self.user_agent  = 'Rails Testing'
+    end
+
+    def env
+      write_cookies!
+      delete_nil_values!
+      super
+    end
+
+    def request_method=(method)
+      @env['REQUEST_METHOD'] = method.to_s.upcase
+    end
+
+    def host=(host)
+      @env['HTTP_HOST'] = host
+    end
+
+    def port=(number)
+      @env['SERVER_PORT'] = number.to_i
+    end
+
+    def request_uri=(uri)
+      @env['REQUEST_URI'] = uri
+    end
+
+    def path=(path)
+      @env['PATH_INFO'] = path
+    end
+
+    def action=(action_name)
+      path_parameters["action"] = action_name.to_s
+    end
+
+    def if_modified_since=(last_modified)
+      @env['HTTP_IF_MODIFIED_SINCE'] = last_modified
+    end
+
+    def if_none_match=(etag)
+      @env['HTTP_IF_NONE_MATCH'] = etag
+    end
+
+    def remote_addr=(addr)
+      @env['REMOTE_ADDR'] = addr
+    end
+
+    def user_agent=(user_agent)
+      @env['HTTP_USER_AGENT'] = user_agent
+    end
+
+    def accept=(mime_types)
+      @env.delete('action_dispatch.request.accepts')
+      @env['HTTP_ACCEPT'] = Array(mime_types).collect { |mime_types| mime_types.to_s }.join(",")
+    end
+
+    def cookies
+      @cookies ||= super
+    end
+
+    private
+      def write_cookies!
+        unless @cookies.blank?
+          @env['HTTP_COOKIE'] = @cookies.map { |name, value| "#{name}=#{value};" }.join(' ')
+        end
+      end
+
+      def delete_nil_values!
+        @env.delete_if { |k, v| v.nil? }
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/testing/test_response.rb b/actionpack/lib/action_dispatch/testing/test_response.rb
new file mode 100644
index 0000000000..c35982e075
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/test_response.rb
@@ -0,0 +1,131 @@
+module ActionDispatch
+  # Integration test methods such as ActionController::Integration::Session#get
+  # and ActionController::Integration::Session#post return objects of class
+  # TestResponse, which represent the HTTP response results of the requested
+  # controller actions.
+  #
+  # See Response for more information on controller response objects.
+  class TestResponse < Response
+    def self.from_response(response)
+      new.tap do |resp|
+        resp.status  = response.status
+        resp.headers = response.headers
+        resp.body    = response.body
+      end
+    end
+
+    module DeprecatedHelpers
+      def template
+        ActiveSupport::Deprecation.warn("response.template has been deprecated. Use controller.template instead", caller)
+        @template
+      end
+      attr_writer :template
+
+      def session
+        ActiveSupport::Deprecation.warn("response.session has been deprecated. Use request.session instead", caller)
+        @request.session
+      end
+
+      def assigns
+        ActiveSupport::Deprecation.warn("response.assigns has been deprecated. Use controller.assigns instead", caller)
+        @template.controller.assigns
+      end
+
+      def layout
+        ActiveSupport::Deprecation.warn("response.layout has been deprecated. Use template.layout instead", caller)
+        @template.layout
+      end
+
+      def redirect_url_match?(pattern)
+        ::ActiveSupport::Deprecation.warn("response.redirect_url_match? is deprecated. Use assert_match(/foo/, response.redirect_url) instead", caller)
+        return false if redirect_url.nil?
+        p = Regexp.new(pattern) if pattern.class == String
+        p = pattern if pattern.class == Regexp
+        return false if p.nil?
+        p.match(redirect_url) != nil
+      end
+
+      # Returns the template of the file which was used to
+      # render this response (or nil)
+      def rendered
+        ActiveSupport::Deprecation.warn("response.rendered has been deprecated. Use tempate.rendered instead", caller)
+        @template.instance_variable_get(:@_rendered)
+      end
+
+      # A shortcut to the flash. Returns an empty hash if no session flash exists.
+      def flash
+        ActiveSupport::Deprecation.warn("response.flash has been deprecated. Use request.flash instead", caller)
+        request.session['flash'] || {}
+      end
+
+      # Do we have a flash?
+      def has_flash?
+        ActiveSupport::Deprecation.warn("response.has_flash? has been deprecated. Use flash.any? instead", caller)
+        !flash.empty?
+      end
+
+      # Do we have a flash that has contents?
+      def has_flash_with_contents?
+        ActiveSupport::Deprecation.warn("response.has_flash_with_contents? has been deprecated. Use flash.any? instead", caller)
+        !flash.empty?
+      end
+
+      # Does the specified flash object exist?
+      def has_flash_object?(name=nil)
+        ActiveSupport::Deprecation.warn("response.has_flash_object? has been deprecated. Use flash[name] instead", caller)
+        !flash[name].nil?
+      end
+
+      # Does the specified object exist in the session?
+      def has_session_object?(name=nil)
+        ActiveSupport::Deprecation.warn("response.has_session_object? has been deprecated. Use session[name] instead", caller)
+        !session[name].nil?
+      end
+
+      # A shortcut to the template.assigns
+      def template_objects
+        ActiveSupport::Deprecation.warn("response.template_objects has been deprecated. Use tempate.assigns instead", caller)
+        @template.assigns || {}
+      end
+
+      # Does the specified template object exist?
+      def has_template_object?(name=nil)
+        ActiveSupport::Deprecation.warn("response.has_template_object? has been deprecated. Use tempate.assigns[name].nil? instead", caller)
+        !template_objects[name].nil?
+      end
+
+      # Returns binary content (downloadable file), converted to a String
+      def binary_content
+        ActiveSupport::Deprecation.warn("response.binary_content has been deprecated. Use response.body instead", caller)
+        body
+      end
+    end
+    include DeprecatedHelpers
+
+    # Was the response successful?
+    def success?
+      (200..299).include?(response_code)
+    end
+
+    # Was the URL not found?
+    def missing?
+      response_code == 404
+    end
+
+    # Were we redirected?
+    def redirect?
+      (300..399).include?(response_code)
+    end
+
+    # Was there a server-side error?
+    def error?
+      (500..599).include?(response_code)
+    end
+    alias_method :server_error?, :error?
+
+    # Was there a client client?
+    def client_error?
+      (400..499).include?(response_code)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack.rb
new file mode 100644
index 0000000000..371d015690
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack.rb
@@ -0,0 +1,90 @@
+# Copyright (C) 2007, 2008, 2009 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Rack is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+path = File.expand_path(File.dirname(__FILE__))
+$:.unshift(path) unless $:.include?(path)
+
+
+# The Rack main module, serving as a namespace for all core Rack
+# modules and classes.
+#
+# All modules meant for use in your application are <tt>autoload</tt>ed here,
+# so it should be enough just to <tt>require rack.rb</tt> in your code.
+
+module Rack
+  # The Rack protocol version number implemented.
+  VERSION = [1,0]
+
+  # Return the Rack protocol version as a dotted string.
+  def self.version
+    VERSION.join(".")
+  end
+
+  # Return the Rack release as a dotted string.
+  def self.release
+    "1.0"
+  end
+
+  autoload :Builder, "rack/builder"
+  autoload :Cascade, "rack/cascade"
+  autoload :Chunked, "rack/chunked"
+  autoload :CommonLogger, "rack/commonlogger"
+  autoload :ConditionalGet, "rack/conditionalget"
+  autoload :ContentLength, "rack/content_length"
+  autoload :ContentType, "rack/content_type"
+  autoload :File, "rack/file"
+  autoload :Deflater, "rack/deflater"
+  autoload :Directory, "rack/directory"
+  autoload :ForwardRequest, "rack/recursive"
+  autoload :Handler, "rack/handler"
+  autoload :Head, "rack/head"
+  autoload :Lint, "rack/lint"
+  autoload :Lock, "rack/lock"
+  autoload :MethodOverride, "rack/methodoverride"
+  autoload :Mime, "rack/mime"
+  autoload :Recursive, "rack/recursive"
+  autoload :Reloader, "rack/reloader"
+  autoload :ShowExceptions, "rack/showexceptions"
+  autoload :ShowStatus, "rack/showstatus"
+  autoload :Static, "rack/static"
+  autoload :URLMap, "rack/urlmap"
+  autoload :Utils, "rack/utils"
+
+  autoload :MockRequest, "rack/mock"
+  autoload :MockResponse, "rack/mock"
+
+  autoload :Request, "rack/request"
+  autoload :Response, "rack/response"
+
+  module Auth
+    autoload :Basic, "rack/auth/basic"
+    autoload :AbstractRequest, "rack/auth/abstract/request"
+    autoload :AbstractHandler, "rack/auth/abstract/handler"
+    autoload :OpenID, "rack/auth/openid"
+    module Digest
+      autoload :MD5, "rack/auth/digest/md5"
+      autoload :Nonce, "rack/auth/digest/nonce"
+      autoload :Params, "rack/auth/digest/params"
+      autoload :Request, "rack/auth/digest/request"
+    end
+  end
+
+  module Session
+    autoload :Cookie, "rack/session/cookie"
+    autoload :Pool, "rack/session/pool"
+    autoload :Memcache, "rack/session/memcache"
+  end
+
+  # *Adapters* connect Rack with third party web frameworks.
+  #
+  # Rack includes an adapter for Camping, see README for other
+  # frameworks supporting Rack in their code bases.
+  #
+  # Refer to the submodules for framework-specific calling details.
+
+  module Adapter
+    autoload :Camping, "rack/adapter/camping"
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/adapter/camping.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/adapter/camping.rb
new file mode 100644
index 0000000000..63bc787f54
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/adapter/camping.rb
@@ -0,0 +1,22 @@
+module Rack
+  module Adapter
+    class Camping
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env["PATH_INFO"] ||= ""
+        env["SCRIPT_NAME"] ||= ""
+        controller = @app.run(env['rack.input'], env)
+        h = controller.headers
+        h.each_pair do |k,v|
+          if v.kind_of? URI
+            h[k] = v.to_s
+          end
+        end
+        [controller.status, controller.headers, [controller.body.to_s]]
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/handler.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/handler.rb
new file mode 100644
index 0000000000..214df6299e
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/handler.rb
@@ -0,0 +1,37 @@
+module Rack
+  module Auth
+    # Rack::Auth::AbstractHandler implements common authentication functionality.
+    #
+    # +realm+ should be set for all handlers.
+
+    class AbstractHandler
+
+      attr_accessor :realm
+
+      def initialize(app, realm=nil, &authenticator)
+        @app, @realm, @authenticator = app, realm, authenticator
+      end
+
+
+      private
+
+      def unauthorized(www_authenticate = challenge)
+        return [ 401,
+          { 'Content-Type' => 'text/plain',
+            'Content-Length' => '0',
+            'WWW-Authenticate' => www_authenticate.to_s },
+          []
+        ]
+      end
+
+      def bad_request
+        return [ 400,
+          { 'Content-Type' => 'text/plain',
+            'Content-Length' => '0' },
+          []
+        ]
+      end
+
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/request.rb
new file mode 100644
index 0000000000..1d9ccec685
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/request.rb
@@ -0,0 +1,37 @@
+module Rack
+  module Auth
+    class AbstractRequest
+
+      def initialize(env)
+        @env = env
+      end
+
+      def provided?
+        !authorization_key.nil?
+      end
+
+      def parts
+        @parts ||= @env[authorization_key].split(' ', 2)
+      end
+
+      def scheme
+        @scheme ||= parts.first.downcase.to_sym
+      end
+
+      def params
+        @params ||= parts.last
+      end
+
+
+      private
+
+      AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
+
+      def authorization_key
+        @authorization_key ||= AUTHORIZATION_KEYS.detect { |key| @env.has_key?(key) }
+      end
+
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/basic.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/basic.rb
new file mode 100644
index 0000000000..9557224648
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/basic.rb
@@ -0,0 +1,58 @@
+require 'rack/auth/abstract/handler'
+require 'rack/auth/abstract/request'
+
+module Rack
+  module Auth
+    # Rack::Auth::Basic implements HTTP Basic Authentication, as per RFC 2617.
+    #
+    # Initialize with the Rack application that you want protecting,
+    # and a block that checks if a username and password pair are valid.
+    #
+    # See also: <tt>example/protectedlobster.rb</tt>
+
+    class Basic < AbstractHandler
+
+      def call(env)
+        auth = Basic::Request.new(env)
+
+        return unauthorized unless auth.provided?
+
+        return bad_request unless auth.basic?
+
+        if valid?(auth)
+          env['REMOTE_USER'] = auth.username
+
+          return @app.call(env)
+        end
+
+        unauthorized
+      end
+
+
+      private
+
+      def challenge
+        'Basic realm="%s"' % realm
+      end
+
+      def valid?(auth)
+        @authenticator.call(*auth.credentials)
+      end
+
+      class Request < Auth::AbstractRequest
+        def basic?
+          :basic == scheme
+        end
+
+        def credentials
+          @credentials ||= params.unpack("m*").first.split(/:/, 2)
+        end
+
+        def username
+          credentials.first
+        end
+      end
+
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/md5.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/md5.rb
new file mode 100644
index 0000000000..e579dc9632
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/md5.rb
@@ -0,0 +1,124 @@
+require 'rack/auth/abstract/handler'
+require 'rack/auth/digest/request'
+require 'rack/auth/digest/params'
+require 'rack/auth/digest/nonce'
+require 'digest/md5'
+
+module Rack
+  module Auth
+    module Digest
+      # Rack::Auth::Digest::MD5 implements the MD5 algorithm version of
+      # HTTP Digest Authentication, as per RFC 2617.
+      #
+      # Initialize with the [Rack] application that you want protecting,
+      # and a block that looks up a plaintext password for a given username.
+      #
+      # +opaque+ needs to be set to a constant base64/hexadecimal string.
+      #
+      class MD5 < AbstractHandler
+
+        attr_accessor :opaque
+
+        attr_writer :passwords_hashed
+
+        def initialize(*args)
+          super
+          @passwords_hashed = nil
+        end
+
+        def passwords_hashed?
+          !!@passwords_hashed
+        end
+
+        def call(env)
+          auth = Request.new(env)
+
+          unless auth.provided?
+            return unauthorized
+          end
+
+          if !auth.digest? || !auth.correct_uri? || !valid_qop?(auth)
+            return bad_request
+          end
+
+          if valid?(auth)
+            if auth.nonce.stale?
+              return unauthorized(challenge(:stale => true))
+            else
+              env['REMOTE_USER'] = auth.username
+
+              return @app.call(env)
+            end
+          end
+
+          unauthorized
+        end
+
+
+        private
+
+        QOP = 'auth'.freeze
+
+        def params(hash = {})
+          Params.new do |params|
+            params['realm'] = realm
+            params['nonce'] = Nonce.new.to_s
+            params['opaque'] = H(opaque)
+            params['qop'] = QOP
+
+            hash.each { |k, v| params[k] = v }
+          end
+        end
+
+        def challenge(hash = {})
+          "Digest #{params(hash)}"
+        end
+
+        def valid?(auth)
+          valid_opaque?(auth) && valid_nonce?(auth) && valid_digest?(auth)
+        end
+
+        def valid_qop?(auth)
+          QOP == auth.qop
+        end
+
+        def valid_opaque?(auth)
+          H(opaque) == auth.opaque
+        end
+
+        def valid_nonce?(auth)
+          auth.nonce.valid?
+        end
+
+        def valid_digest?(auth)
+          digest(auth, @authenticator.call(auth.username)) == auth.response
+        end
+
+        def md5(data)
+          ::Digest::MD5.hexdigest(data)
+        end
+
+        alias :H :md5
+
+        def KD(secret, data)
+          H([secret, data] * ':')
+        end
+
+        def A1(auth, password)
+          [ auth.username, auth.realm, password ] * ':'
+        end
+
+        def A2(auth)
+          [ auth.method, auth.uri ] * ':'
+        end
+
+        def digest(auth, password)
+          password_hash = passwords_hashed? ? password : H(A1(auth, password))
+
+          KD(password_hash, [ auth.nonce, auth.nc, auth.cnonce, QOP, H(A2(auth)) ] * ':')
+        end
+
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/nonce.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/nonce.rb
new file mode 100644
index 0000000000..dbe109f29a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/nonce.rb
@@ -0,0 +1,51 @@
+require 'digest/md5'
+
+module Rack
+  module Auth
+    module Digest
+      # Rack::Auth::Digest::Nonce is the default nonce generator for the
+      # Rack::Auth::Digest::MD5 authentication handler.
+      #
+      # +private_key+ needs to set to a constant string.
+      #
+      # +time_limit+ can be optionally set to an integer (number of seconds),
+      # to limit the validity of the generated nonces.
+
+      class Nonce
+
+        class << self
+          attr_accessor :private_key, :time_limit
+        end
+
+        def self.parse(string)
+          new(*string.unpack("m*").first.split(' ', 2))
+        end
+
+        def initialize(timestamp = Time.now, given_digest = nil)
+          @timestamp, @given_digest = timestamp.to_i, given_digest
+        end
+
+        def to_s
+          [([ @timestamp, digest ] * ' ')].pack("m*").strip
+        end
+
+        def digest
+          ::Digest::MD5.hexdigest([ @timestamp, self.class.private_key ] * ':')
+        end
+
+        def valid?
+          digest == @given_digest
+        end
+
+        def stale?
+          !self.class.time_limit.nil? && (@timestamp - Time.now.to_i) < self.class.time_limit
+        end
+
+        def fresh?
+          !stale?
+        end
+
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/params.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/params.rb
new file mode 100644
index 0000000000..730e2efdc8
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/params.rb
@@ -0,0 +1,55 @@
+module Rack
+  module Auth
+    module Digest
+      class Params < Hash
+
+        def self.parse(str)
+          split_header_value(str).inject(new) do |header, param|
+            k, v = param.split('=', 2)
+            header[k] = dequote(v)
+            header
+          end
+        end
+
+        def self.dequote(str) # From WEBrick::HTTPUtils
+          ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
+          ret.gsub!(/\\(.)/, "\\1")
+          ret
+        end
+
+        def self.split_header_value(str)
+          str.scan( /(\w+\=(?:"[^\"]+"|[^,]+))/n ).collect{ |v| v[0] }
+        end
+
+        def initialize
+          super
+
+          yield self if block_given?
+        end
+
+        def [](k)
+          super k.to_s
+        end
+
+        def []=(k, v)
+          super k.to_s, v.to_s
+        end
+
+        UNQUOTED = ['qop', 'nc', 'stale']
+
+        def to_s
+          inject([]) do |parts, (k, v)|
+            parts << "#{k}=" + (UNQUOTED.include?(k) ? v.to_s : quote(v))
+            parts
+          end.join(', ')
+        end
+
+        def quote(str) # From WEBrick::HTTPUtils
+          '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
+        end
+
+      end
+    end
+  end
+end
+
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/request.rb
new file mode 100644
index 0000000000..a8aa3bf996
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/request.rb
@@ -0,0 +1,40 @@
+require 'rack/auth/abstract/request'
+require 'rack/auth/digest/params'
+require 'rack/auth/digest/nonce'
+
+module Rack
+  module Auth
+    module Digest
+      class Request < Auth::AbstractRequest
+
+        def method
+          @env['rack.methodoverride.original_method'] || @env['REQUEST_METHOD']
+        end
+
+        def digest?
+          :digest == scheme
+        end
+
+        def correct_uri?
+          (@env['SCRIPT_NAME'].to_s + @env['PATH_INFO'].to_s) == uri
+        end
+
+        def nonce
+          @nonce ||= Nonce.parse(params['nonce'])
+        end
+
+        def params
+          @params ||= Params.parse(parts.last)
+        end
+
+        def method_missing(sym)
+          if params.has_key? key = sym.to_s
+            return params[key]
+          end
+          super
+        end
+
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/openid.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/openid.rb
new file mode 100644
index 0000000000..c5f6a5143e
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/openid.rb
@@ -0,0 +1,480 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+
+gem 'ruby-openid', '~> 2' if defined? Gem
+require 'rack/request'
+require 'rack/utils'
+require 'rack/auth/abstract/handler'
+require 'uri'
+require 'openid' #gem
+require 'openid/extension' #gem
+require 'openid/store/memory' #gem
+
+module Rack
+  class Request
+    def openid_request
+      @env['rack.auth.openid.request']
+    end
+
+    def openid_response
+      @env['rack.auth.openid.response']
+    end
+  end
+
+  module Auth
+
+    # Rack::Auth::OpenID provides a simple method for setting up an OpenID
+    # Consumer. It requires the ruby-openid library from janrain to operate,
+    # as well as a rack method of session management.
+    #
+    # The ruby-openid home page is at http://openidenabled.com/ruby-openid/.
+    #
+    # The OpenID specifications can be found at
+    # http://openid.net/specs/openid-authentication-1_1.html
+    # and
+    # http://openid.net/specs/openid-authentication-2_0.html. Documentation
+    # for published OpenID extensions and related topics can be found at
+    # http://openid.net/developers/specs/.
+    #
+    # It is recommended to read through the OpenID spec, as well as
+    # ruby-openid's documentation, to understand what exactly goes on. However
+    # a setup as simple as the presented examples is enough to provide
+    # Consumer functionality.
+    #
+    # This library strongly intends to utilize the OpenID 2.0 features of the
+    # ruby-openid library, which provides OpenID 1.0 compatiblity.
+    #
+    # NOTE: Due to the amount of data that this library stores in the
+    # session, Rack::Session::Cookie may fault.
+
+    class OpenID
+
+      class NoSession < RuntimeError; end
+      class BadExtension < RuntimeError; end
+      # Required for ruby-openid
+      ValidStatus = [:success, :setup_needed, :cancel, :failure]
+
+      # = Arguments
+      #
+      # The first argument is the realm, identifying the site they are trusting
+      # with their identity. This is required, also treated as the trust_root
+      # in OpenID 1.x exchanges.
+      #
+      # The optional second argument is a hash of options.
+      #
+      # == Options
+      #
+      # <tt>:return_to</tt> defines the url to return to after the client
+      # authenticates with the openid service provider. This url should point
+      # to where Rack::Auth::OpenID is mounted. If <tt>:return_to</tt> is not
+      # provided, return_to will be the current url which allows flexibility
+      # with caveats.
+      #
+      # <tt>:session_key</tt> defines the key to the session hash in the env.
+      # It defaults to 'rack.session'.
+      #
+      # <tt>:openid_param</tt> defines at what key in the request parameters to
+      # find the identifier to resolve. As per the 2.0 spec, the default is
+      # 'openid_identifier'.
+      #
+      # <tt>:store</tt> defined what OpenID Store to use for persistant
+      # information. By default a Store::Memory will be used.
+      #
+      # <tt>:immediate</tt> as true will make initial requests to be of an
+      # immediate type. This is false by default. See OpenID specification
+      # documentation.
+      #
+      # <tt>:extensions</tt> should be a hash of openid extension
+      # implementations. The key should be the extension main module, the value
+      # should be an array of arguments for extension::Request.new.
+      # The hash is iterated over and passed to #add_extension for processing.
+      # Please see #add_extension for further documentation.
+      #
+      # == Examples
+      #
+      #   simple_oid = OpenID.new('http://mysite.com/')
+      #
+      #   return_oid = OpenID.new('http://mysite.com/', {
+      #     :return_to => 'http://mysite.com/openid'
+      #   })
+      #
+      #   complex_oid = OpenID.new('http://mysite.com/',
+      #     :immediate => true,
+      #     :extensions => {
+      #       ::OpenID::SReg => [['email'],['nickname']]
+      #     }
+      #   )
+      #
+      # = Advanced
+      #
+      # Most of the functionality of this library is encapsulated such that
+      # expansion and overriding functions isn't difficult nor tricky.
+      # Alternately, to avoid opening up singleton objects or subclassing, a
+      # wrapper rack middleware can be composed to act upon Auth::OpenID's
+      # responses. See #check and #finish for locations of pertinent data.
+      #
+      # == Responses
+      #
+      # To change the responses that Auth::OpenID returns, override the methods
+      # #redirect, #bad_request, #unauthorized, #access_denied, and
+      # #foreign_server_failure.
+      #
+      # Additionally #confirm_post_params is used when the URI would exceed
+      # length limits on a GET request when doing the initial verification
+      # request.
+      #
+      # == Processing
+      #
+      # To change methods of processing completed transactions, override the
+      # methods #success, #setup_needed, #cancel, and #failure. Please ensure
+      # the returned object is a rack compatible response.
+      #
+      # The first argument is an OpenID::Response, the second is a
+      # Rack::Request of the current request, the last is the hash used in
+      # ruby-openid handling, which can be found manually at
+      # env['rack.session'][:openid].
+      #
+      # This is useful if you wanted to expand the processing done, such as
+      # setting up user accounts.
+      #
+      #   oid_app = Rack::Auth::OpenID.new realm, :return_to => return_to
+      #   def oid_app.success oid, request, session
+      #     user = Models::User[oid.identity_url]
+      #     user ||= Models::User.create_from_openid oid
+      #     request['rack.session'][:user] = user.id
+      #     redirect MyApp.site_home
+      #   end
+      #
+      #   site_map['/openid'] = oid_app
+      #   map = Rack::URLMap.new site_map
+      #   ...
+
+      def initialize(realm, options={})
+        realm = URI(realm)
+        raise ArgumentError, "Invalid realm: #{realm}" \
+          unless realm.absolute? \
+          and realm.fragment.nil? \
+          and realm.scheme =~ /^https?$/ \
+          and realm.host =~ /^(\*\.)?#{URI::REGEXP::PATTERN::URIC_NO_SLASH}+/
+        realm.path = '/' if realm.path.empty?
+        @realm = realm.to_s
+
+        if ruri = options[:return_to]
+          ruri = URI(ruri)
+          raise ArgumentError, "Invalid return_to: #{ruri}" \
+            unless ruri.absolute? \
+            and ruri.scheme  =~ /^https?$/ \
+            and ruri.fragment.nil?
+          raise ArgumentError, "return_to #{ruri} not within realm #{realm}" \
+            unless self.within_realm?(ruri)
+          @return_to = ruri.to_s
+        end
+
+        @session_key  = options[:session_key]   || 'rack.session'
+        @openid_param = options[:openid_param]  || 'openid_identifier'
+        @store        = options[:store]         || ::OpenID::Store::Memory.new
+        @immediate    = !!options[:immediate]
+
+        @extensions = {}
+        if extensions = options.delete(:extensions)
+          extensions.each do |ext, args|
+            add_extension ext, *args
+          end
+        end
+
+        # Undocumented, semi-experimental
+        @anonymous    = !!options[:anonymous]
+      end
+
+      attr_reader :realm, :return_to, :session_key, :openid_param, :store,
+        :immediate, :extensions
+
+      # Sets up and uses session data at <tt>:openid</tt> within the session.
+      # Errors in this setup will raise a NoSession exception.
+      #
+      # If the parameter 'openid.mode' is set, which implies a followup from
+      # the openid server, processing is passed to #finish and the result is
+      # returned. However, if there is no appropriate openid information in the
+      # session, a 400 error is returned.
+      #
+      # If the parameter specified by <tt>options[:openid_param]</tt> is
+      # present, processing is passed to #check and the result is returned.
+      #
+      # If neither of these conditions are met, #unauthorized is called.
+
+      def call(env)
+        env['rack.auth.openid'] = self
+        env_session = env[@session_key]
+        unless env_session and env_session.is_a?(Hash)
+          raise NoSession, 'No compatible session'
+        end
+        # let us work in our own namespace...
+        session = (env_session[:openid] ||= {})
+        unless session and session.is_a?(Hash)
+          raise NoSession, 'Incompatible openid session'
+        end
+
+        request = Rack::Request.new(env)
+        consumer = ::OpenID::Consumer.new(session, @store)
+
+        if mode = request.GET['openid.mode']
+          if session.key?(:openid_param)
+            finish(consumer, session, request)
+          else
+            bad_request
+          end
+        elsif request.GET[@openid_param]
+          check(consumer, session, request)
+        else
+          unauthorized
+        end
+      end
+
+      # As the first part of OpenID consumer action, #check retrieves the data
+      # required for completion.
+      #
+      # If all parameters fit within the max length of a URI, a 303 redirect
+      # will be returned. Otherwise #confirm_post_params will be called.
+      #
+      # Any messages from OpenID's request are logged to env['rack.errors']
+      #
+      # <tt>env['rack.auth.openid.request']</tt> is the openid checkid request
+      # instance.
+      #
+      # <tt>session[:openid_param]</tt> is set to the openid identifier
+      # provided by the user.
+      #
+      # <tt>session[:return_to]</tt> is set to the return_to uri given to the
+      # identity provider.
+
+      def check(consumer, session, req)
+        oid = consumer.begin(req.GET[@openid_param], @anonymous)
+        req.env['rack.auth.openid.request'] = oid
+        req.env['rack.errors'].puts(oid.message)
+        p oid if $DEBUG
+
+        ## Extension support
+        extensions.each do |ext,args|
+          oid.add_extension(ext::Request.new(*args))
+        end
+
+        session[:openid_param] = req.GET[openid_param]
+        return_to_uri = return_to ? return_to : req.url
+        session[:return_to] = return_to_uri
+        immediate = session.key?(:setup_needed) ? false : immediate
+
+        if oid.send_redirect?(realm, return_to_uri, immediate)
+          uri = oid.redirect_url(realm, return_to_uri, immediate)
+          redirect(uri)
+        else
+          confirm_post_params(oid, realm, return_to_uri, immediate)
+        end
+      rescue ::OpenID::DiscoveryFailure => e
+        # thrown from inside OpenID::Consumer#begin by yadis stuff
+        req.env['rack.errors'].puts([e.message, *e.backtrace]*"\n")
+        return foreign_server_failure
+      end
+
+      # This is the final portion of authentication.
+      # If successful, a redirect to the realm is be returned.
+      # Data gathered from extensions are stored in session[:openid] with the
+      # extension's namespace uri as the key.
+      #
+      # Any messages from OpenID's response are logged to env['rack.errors']
+      #
+      # <tt>env['rack.auth.openid.response']</tt> will contain the openid
+      # response.
+
+      def finish(consumer, session, req)
+        oid = consumer.complete(req.GET, req.url)
+        req.env['rack.auth.openid.response'] = oid
+        req.env['rack.errors'].puts(oid.message)
+        p oid if $DEBUG
+
+        raise unless ValidStatus.include?(oid.status)
+        __send__(oid.status, oid, req, session)
+      end
+
+      # The first argument should be the main extension module.
+      # The extension module should contain the constants:
+      #   * class Request, should have OpenID::Extension as an ancestor
+      #   * class Response, should have OpenID::Extension as an ancestor
+      #   * string NS_URI, which defining the namespace of the extension
+      #
+      # All trailing arguments will be passed to extension::Request.new in
+      # #check.
+      # The openid response will be passed to
+      # extension::Response#from_success_response, #get_extension_args will be
+      # called on the result to attain the gathered data.
+      #
+      # This method returns the key at which the response data will be found in
+      # the session, which is the namespace uri by default.
+
+      def add_extension(ext, *args)
+        raise BadExtension unless valid_extension?(ext)
+        extensions[ext] = args
+        return ext::NS_URI
+      end
+
+      # Checks the validitity, in the context of usage, of a submitted
+      # extension.
+
+      def valid_extension?(ext)
+        if not %w[NS_URI Request Response].all?{|c| ext.const_defined?(c) }
+          raise ArgumentError, 'Extension is missing constants.'
+        elsif not ext::Response.respond_to?(:from_success_response)
+          raise ArgumentError, 'Response is missing required method.'
+        end
+        return true
+      rescue
+        return false
+      end
+
+      # Checks the provided uri to ensure it'd be considered within the realm.
+      # is currently not compatible with wildcard realms.
+
+      def within_realm? uri
+        uri = URI.parse(uri.to_s)
+        realm = URI.parse(self.realm)
+        return false unless uri.absolute?
+        return false unless uri.path[0, realm.path.size] == realm.path
+        return false unless uri.host == realm.host or realm.host[/^\*\./]
+        # for wildcard support, is awkward with URI limitations
+        realm_match = Regexp.escape(realm.host).
+          sub(/^\*\./,"^#{URI::REGEXP::PATTERN::URIC_NO_SLASH}+.")+'$'
+        return false unless uri.host.match(realm_match)
+        return true
+      end
+      alias_method :include?, :within_realm?
+
+      protected
+
+      ### These methods define some of the boilerplate responses.
+
+      # Returns an html form page for posting to an Identity Provider if the
+      # GET request would exceed the upper URI length limit.
+
+      def confirm_post_params(oid, realm, return_to, immediate)
+        Rack::Response.new.finish do |r|
+          r.write '<html><head><title>Confirm...</title></head><body>'
+          r.write oid.form_markup(realm, return_to, immediate)
+          r.write '</body></html>'
+        end
+      end
+
+      # Returns a 303 redirect with the destination of that provided by the
+      # argument.
+
+      def redirect(uri)
+        [ 303, {'Content-Length'=>'0', 'Content-Type'=>'text/plain',
+          'Location' => uri},
+          [] ]
+      end
+
+      # Returns an empty 400 response.
+
+      def bad_request
+        [ 400, {'Content-Type'=>'text/plain', 'Content-Length'=>'0'},
+          [''] ]
+      end
+
+      # Returns a basic unauthorized 401 response.
+
+      def unauthorized
+        [ 401, {'Content-Type' => 'text/plain', 'Content-Length' => '13'},
+          ['Unauthorized.'] ]
+      end
+
+      # Returns a basic access denied 403 response.
+
+      def access_denied
+        [ 403, {'Content-Type' => 'text/plain', 'Content-Length' => '14'},
+          ['Access denied.'] ]
+      end
+
+      # Returns a 503 response to be used if communication with the remote
+      # OpenID server fails.
+
+      def foreign_server_failure
+        [ 503, {'Content-Type'=>'text/plain', 'Content-Length' => '23'},
+          ['Foreign server failure.'] ]
+      end
+
+      private
+
+      ### These methods are called after a transaction is completed, depending
+      # on its outcome. These should all return a rack compatible response.
+      # You'd want to override these to provide additional functionality.
+
+      # Called to complete processing on a successful transaction.
+      # Within the openid session, :openid_identity and :openid_identifier are
+      # set to the user friendly and the standard representation of the
+      # validated identity. All other data in the openid session is cleared.
+
+      def success(oid, request, session)
+        session.clear
+        session[:openid_identity]   = oid.display_identifier
+        session[:openid_identifier] = oid.identity_url
+        extensions.keys.each do |ext|
+          label     = ext.name[/[^:]+$/].downcase
+          response  = ext::Response.from_success_response(oid)
+          session[label] = response.data
+        end
+        redirect(realm)
+      end
+
+      # Called if the Identity Provider indicates further setup by the user is
+      # required.
+      # The identifier is retrived from the openid session at :openid_param.
+      # And :setup_needed is set to true to prevent looping.
+
+      def setup_needed(oid, request, session)
+        identifier = session[:openid_param]
+        session[:setup_needed] = true
+        redirect req.script_name + '?' + openid_param + '=' + identifier
+      end
+
+      # Called if the user indicates they wish to cancel identification.
+      # Data within openid session is cleared.
+
+      def cancel(oid, request, session)
+        session.clear
+        access_denied
+      end
+
+      # Called if the Identity Provider indicates the user is unable to confirm
+      # their identity. Data within the openid session is left alone, in case
+      # of swarm auth attacks.
+
+      def failure(oid, request, session)
+        unauthorized
+      end
+    end
+
+    # A class developed out of the request to use OpenID as an authentication
+    # middleware. The request will be sent to the OpenID instance unless the
+    # block evaluates to true. For example in rackup, you can use it as such:
+    #
+    #   use Rack::Session::Pool
+    #   use Rack::Auth::OpenIDAuth, realm, openid_options do |env|
+    #     env['rack.session'][:authkey] == a_string
+    #   end
+    #   run RackApp
+    #
+    # Or simply:
+    #
+    #   app = Rack::Auth::OpenIDAuth.new app, realm, openid_options, &auth
+
+    class OpenIDAuth < Rack::Auth::AbstractHandler
+      attr_reader :oid
+      def initialize(app, realm, options={}, &auth)
+        @oid = OpenID.new(realm, options)
+        super(app, &auth)
+      end
+
+      def call(env)
+        to = auth.call(env) ? @app : @oid
+        to.call env
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/builder.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/builder.rb
new file mode 100644
index 0000000000..295235e56a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/builder.rb
@@ -0,0 +1,63 @@
+module Rack
+  # Rack::Builder implements a small DSL to iteratively construct Rack
+  # applications.
+  #
+  # Example:
+  #
+  #  app = Rack::Builder.new {
+  #    use Rack::CommonLogger
+  #    use Rack::ShowExceptions
+  #    map "/lobster" do
+  #      use Rack::Lint
+  #      run Rack::Lobster.new
+  #    end
+  #  }
+  #
+  # Or
+  #
+  #  app = Rack::Builder.app do
+  #    use Rack::CommonLogger
+  #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
+  #  end
+  #
+  # +use+ adds a middleware to the stack, +run+ dispatches to an application.
+  # You can use +map+ to construct a Rack::URLMap in a convenient way.
+
+  class Builder
+    def initialize(&block)
+      @ins = []
+      instance_eval(&block) if block_given?
+    end
+
+    def self.app(&block)
+      self.new(&block).to_app
+    end
+
+    def use(middleware, *args, &block)
+      @ins << lambda { |app| middleware.new(app, *args, &block) }
+    end
+
+    def run(app)
+      @ins << app #lambda { |nothing| app }
+    end
+
+    def map(path, &block)
+      if @ins.last.kind_of? Hash
+        @ins.last[path] = self.class.new(&block).to_app
+      else
+        @ins << {}
+        map(path, &block)
+      end
+    end
+
+    def to_app
+      @ins[-1] = Rack::URLMap.new(@ins.last)  if Hash === @ins.last
+      inner_app = @ins.last
+      @ins[0...-1].reverse.inject(inner_app) { |a, e| e.call(a) }
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/cascade.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/cascade.rb
new file mode 100644
index 0000000000..a038aa1105
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/cascade.rb
@@ -0,0 +1,36 @@
+module Rack
+  # Rack::Cascade tries an request on several apps, and returns the
+  # first response that is not 404 (or in a list of configurable
+  # status codes).
+
+  class Cascade
+    attr_reader :apps
+
+    def initialize(apps, catch=404)
+      @apps = apps
+      @catch = [*catch]
+    end
+
+    def call(env)
+      status = headers = body = nil
+      raise ArgumentError, "empty cascade"  if @apps.empty?
+      @apps.each { |app|
+        begin
+          status, headers, body = app.call(env)
+          break  unless @catch.include?(status.to_i)
+        end
+      }
+      [status, headers, body]
+    end
+
+    def add app
+      @apps << app
+    end
+
+    def include? app
+      @apps.include? app
+    end
+
+    alias_method :<<, :add
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/chunked.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/chunked.rb
new file mode 100644
index 0000000000..280d89dd65
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/chunked.rb
@@ -0,0 +1,49 @@
+require 'rack/utils'
+
+module Rack
+
+  # Middleware that applies chunked transfer encoding to response bodies
+  # when the response does not include a Content-Length header.
+  class Chunked
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash.new(headers)
+
+      if env['HTTP_VERSION'] == 'HTTP/1.0' ||
+         STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+         headers['Content-Length'] ||
+         headers['Transfer-Encoding']
+        [status, headers.to_hash, body]
+      else
+        dup.chunk(status, headers, body)
+      end
+    end
+
+    def chunk(status, headers, body)
+      @body = body
+      headers.delete('Content-Length')
+      headers['Transfer-Encoding'] = 'chunked'
+      [status, headers.to_hash, self]
+    end
+
+    def each
+      term = "\r\n"
+      @body.each do |chunk|
+        size = bytesize(chunk)
+        next if size == 0
+        yield [size.to_s(16), term, chunk, term].join
+      end
+      yield ["0", term, "", term].join
+    end
+
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/commonlogger.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/commonlogger.rb
new file mode 100644
index 0000000000..5e68ac626d
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/commonlogger.rb
@@ -0,0 +1,61 @@
+module Rack
+  # Rack::CommonLogger forwards every request to an +app+ given, and
+  # logs a line in the Apache common log format to the +logger+, or
+  # rack.errors by default.
+
+  class CommonLogger
+    def initialize(app, logger=nil)
+      @app = app
+      @logger = logger
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @env = env
+      @logger ||= self
+      @time = Time.now
+      @status, @header, @body = @app.call(env)
+      [@status, @header, self]
+    end
+
+    def close
+      @body.close if @body.respond_to? :close
+    end
+
+    # By default, log to rack.errors.
+    def <<(str)
+      @env["rack.errors"].write(str)
+      @env["rack.errors"].flush
+    end
+
+    def each
+      length = 0
+      @body.each { |part|
+        length += part.size
+        yield part
+      }
+
+      @now = Time.now
+
+      # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+      # lilith.local - - [07/Aug/2006 23:58:02] "GET / HTTP/1.1" 500 -
+      #             %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+      @logger << %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n} %
+        [
+         @env['HTTP_X_FORWARDED_FOR'] || @env["REMOTE_ADDR"] || "-",
+         @env["REMOTE_USER"] || "-",
+         @now.strftime("%d/%b/%Y %H:%M:%S"),
+         @env["REQUEST_METHOD"],
+         @env["PATH_INFO"],
+         @env["QUERY_STRING"].empty? ? "" : "?"+@env["QUERY_STRING"],
+         @env["HTTP_VERSION"],
+         @status.to_s[0..3],
+         (length.zero? ? "-" : length.to_s),
+         @now - @time
+        ]
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/conditionalget.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/conditionalget.rb
new file mode 100644
index 0000000000..046ebdb00a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/conditionalget.rb
@@ -0,0 +1,47 @@
+require 'rack/utils'
+
+module Rack
+
+  # Middleware that enables conditional GET using If-None-Match and
+  # If-Modified-Since. The application should set either or both of the
+  # Last-Modified or Etag response headers according to RFC 2616. When
+  # either of the conditions is met, the response body is set to be zero
+  # length and the response status is set to 304 Not Modified.
+  #
+  # Applications that defer response body generation until the body's each
+  # message is received will avoid response body generation completely when
+  # a conditional GET matches.
+  #
+  # Adapted from Michael Klishin's Merb implementation:
+  # http://github.com/wycats/merb-core/tree/master/lib/merb-core/rack/middleware/conditional_get.rb
+  class ConditionalGet
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      return @app.call(env) unless %w[GET HEAD].include?(env['REQUEST_METHOD'])
+
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+      if etag_matches?(env, headers) || modified_since?(env, headers)
+        status = 304
+        headers.delete('Content-Type')
+        headers.delete('Content-Length')
+        body = []
+      end
+      [status, headers, body]
+    end
+
+  private
+    def etag_matches?(env, headers)
+      etag = headers['Etag'] and etag == env['HTTP_IF_NONE_MATCH']
+    end
+
+    def modified_since?(env, headers)
+      last_modified = headers['Last-Modified'] and
+        last_modified == env['HTTP_IF_MODIFIED_SINCE']
+    end
+  end
+
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_length.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_length.rb
new file mode 100644
index 0000000000..1e56d43853
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_length.rb
@@ -0,0 +1,29 @@
+require 'rack/utils'
+
+module Rack
+  # Sets the Content-Length header on responses with fixed-length bodies.
+  class ContentLength
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash.new(headers)
+
+      if !STATUS_WITH_NO_ENTITY_BODY.include?(status) &&
+         !headers['Content-Length'] &&
+         !headers['Transfer-Encoding'] &&
+         (body.respond_to?(:to_ary) || body.respond_to?(:to_str))
+
+        body = [body] if body.respond_to?(:to_str) # rack 0.4 compat
+        length = body.to_ary.inject(0) { |len, part| len + bytesize(part) }
+        headers['Content-Length'] = length.to_s
+      end
+
+      [status, headers, body]
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_type.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_type.rb
new file mode 100644
index 0000000000..0c1e1ca3e1
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_type.rb
@@ -0,0 +1,23 @@
+require 'rack/utils'
+
+module Rack
+
+  # Sets the Content-Type header on responses which don't have one.
+  #
+  # Builder Usage:
+  #   use Rack::ContentType, "text/plain"
+  #
+  # When no content type argument is provided, "text/html" is assumed.
+  class ContentType
+    def initialize(app, content_type = "text/html")
+      @app, @content_type = app, content_type
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+      headers['Content-Type'] ||= @content_type
+      [status, headers.to_hash, body]
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/deflater.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/deflater.rb
new file mode 100644
index 0000000000..14137a944d
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/deflater.rb
@@ -0,0 +1,96 @@
+require "zlib"
+require "stringio"
+require "time"  # for Time.httpdate
+require 'rack/utils'
+
+module Rack
+  class Deflater
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+
+      # Skip compressing empty entity body responses and responses with
+      # no-transform set.
+      if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+          headers['Cache-Control'].to_s =~ /\bno-transform\b/
+        return [status, headers, body]
+      end
+
+      request = Request.new(env)
+
+      encoding = Utils.select_best_encoding(%w(gzip deflate identity),
+                                            request.accept_encoding)
+
+      # Set the Vary HTTP header.
+      vary = headers["Vary"].to_s.split(",").map { |v| v.strip }
+      unless vary.include?("*") || vary.include?("Accept-Encoding")
+        headers["Vary"] = vary.push("Accept-Encoding").join(",")
+      end
+
+      case encoding
+      when "gzip"
+        headers['Content-Encoding'] = "gzip"
+        headers.delete('Content-Length')
+        mtime = headers.key?("Last-Modified") ?
+          Time.httpdate(headers["Last-Modified"]) : Time.now
+        [status, headers, GzipStream.new(body, mtime)]
+      when "deflate"
+        headers['Content-Encoding'] = "deflate"
+        headers.delete('Content-Length')
+        [status, headers, DeflateStream.new(body)]
+      when "identity"
+        [status, headers, body]
+      when nil
+        message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
+        [406, {"Content-Type" => "text/plain", "Content-Length" => message.length.to_s}, [message]]
+      end
+    end
+
+    class GzipStream
+      def initialize(body, mtime)
+        @body = body
+        @mtime = mtime
+      end
+
+      def each(&block)
+        @writer = block
+        gzip  =::Zlib::GzipWriter.new(self)
+        gzip.mtime = @mtime
+        @body.each { |part| gzip << part }
+        @body.close if @body.respond_to?(:close)
+        gzip.close
+        @writer = nil
+      end
+
+      def write(data)
+        @writer.call(data)
+      end
+    end
+
+    class DeflateStream
+      DEFLATE_ARGS = [
+        Zlib::DEFAULT_COMPRESSION,
+        # drop the zlib header which causes both Safari and IE to choke
+        -Zlib::MAX_WBITS,
+        Zlib::DEF_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      ]
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        deflater = ::Zlib::Deflate.new(*DEFLATE_ARGS)
+        @body.each { |part| yield deflater.deflate(part) }
+        @body.close if @body.respond_to?(:close)
+        yield deflater.finish
+        nil
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/directory.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/directory.rb
new file mode 100644
index 0000000000..acdd3029d3
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/directory.rb
@@ -0,0 +1,153 @@
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+
+module Rack
+  # Rack::Directory serves entries below the +root+ given, according to the
+  # path info of the Rack request. If a directory is found, the file's contents
+  # will be presented in an html based index. If a file is found, the env will
+  # be passed to the specified +app+.
+  #
+  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
+
+  class Directory
+    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
+    DIR_PAGE = <<-PAGE
+<html><head>
+  <title>%s</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <style type='text/css'>
+table { width:100%%; }
+.name { text-align:left; }
+.size, .mtime { text-align:right; }
+.type { width:11em; }
+.mtime { width:15em; }
+  </style>
+</head><body>
+<h1>%s</h1>
+<hr />
+<table>
+  <tr>
+    <th class='name'>Name</th>
+    <th class='size'>Size</th>
+    <th class='type'>Type</th>
+    <th class='mtime'>Last Modified</th>
+  </tr>
+%s
+</table>
+<hr />
+</body></html>
+    PAGE
+
+    attr_reader :files
+    attr_accessor :root, :path
+
+    def initialize(root, app=nil)
+      @root = F.expand_path(root)
+      @app = app || Rack::File.new(@root)
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    F = ::File
+
+    def _call(env)
+      @env = env
+      @script_name = env['SCRIPT_NAME']
+      @path_info = Utils.unescape(env['PATH_INFO'])
+
+      if forbidden = check_forbidden
+        forbidden
+      else
+        @path = F.join(@root, @path_info)
+        list_path
+      end
+    end
+
+    def check_forbidden
+      return unless @path_info.include? ".."
+
+      body = "Forbidden\n"
+      size = Rack::Utils.bytesize(body)
+      return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
+    end
+
+    def list_directory
+      @files = [['../','Parent Directory','','','']]
+      glob = F.join(@path, '*')
+
+      Dir[glob].sort.each do |node|
+        stat = stat(node)
+        next  unless stat
+        basename = F.basename(node)
+        ext = F.extname(node)
+
+        url = F.join(@script_name, @path_info, basename)
+        size = stat.size
+        type = stat.directory? ? 'directory' : Mime.mime_type(ext)
+        size = stat.directory? ? '-' : filesize_format(size)
+        mtime = stat.mtime.httpdate
+        url << '/'  if stat.directory?
+        basename << '/'  if stat.directory?
+
+        @files << [ url, basename, size, type, mtime ]
+      end
+
+      return [ 200, {'Content-Type'=>'text/html; charset=utf-8'}, self ]
+    end
+
+    def stat(node, max = 10)
+      F.stat(node)
+    rescue Errno::ENOENT, Errno::ELOOP
+      return nil
+    end
+
+    # TODO: add correct response if not readable, not sure if 404 is the best
+    #       option
+    def list_path
+      @stat = F.stat(@path)
+
+      if @stat.readable?
+        return @app.call(@env) if @stat.file?
+        return list_directory if @stat.directory?
+      else
+        raise Errno::ENOENT, 'No such file or directory'
+      end
+
+    rescue Errno::ENOENT, Errno::ELOOP
+      return entity_not_found
+    end
+
+    def entity_not_found
+      body = "Entity not found: #{@path_info}\n"
+      size = Rack::Utils.bytesize(body)
+      return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
+    end
+
+    def each
+      show_path = @path.sub(/^#{@root}/,'')
+      files = @files.map{|f| DIR_FILE % f }*"\n"
+      page  = DIR_PAGE % [ show_path, show_path , files ]
+      page.each_line{|l| yield l }
+    end
+
+    # Stolen from Ramaze
+
+    FILESIZE_FORMAT = [
+      ['%.1fT', 1 << 40],
+      ['%.1fG', 1 << 30],
+      ['%.1fM', 1 << 20],
+      ['%.1fK', 1 << 10],
+    ]
+
+    def filesize_format(int)
+      FILESIZE_FORMAT.each do |format, size|
+        return format % (int.to_f / size) if int >= size
+      end
+
+      int.to_s + 'B'
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/file.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/file.rb
new file mode 100644
index 0000000000..fe62bd6b86
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/file.rb
@@ -0,0 +1,88 @@
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+
+module Rack
+  # Rack::File serves files below the +root+ given, according to the
+  # path info of the Rack request.
+  #
+  # Handlers can detect if bodies are a Rack::File, and use mechanisms
+  # like sendfile on the +path+.
+
+  class File
+    attr_accessor :root
+    attr_accessor :path
+
+    alias :to_path :path
+
+    def initialize(root)
+      @root = root
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    F = ::File
+
+    def _call(env)
+      @path_info = Utils.unescape(env["PATH_INFO"])
+      return forbidden  if @path_info.include? ".."
+
+      @path = F.join(@root, @path_info)
+
+      begin
+        if F.file?(@path) && F.readable?(@path)
+          serving
+        else
+          raise Errno::EPERM
+        end
+      rescue SystemCallError
+        not_found
+      end
+    end
+
+    def forbidden
+      body = "Forbidden\n"
+      [403, {"Content-Type" => "text/plain",
+             "Content-Length" => body.size.to_s},
+       [body]]
+    end
+
+    # NOTE:
+    #   We check via File::size? whether this file provides size info
+    #   via stat (e.g. /proc files often don't), otherwise we have to
+    #   figure it out by reading the whole file into memory. And while
+    #   we're at it we also use this as body then.
+
+    def serving
+      if size = F.size?(@path)
+        body = self
+      else
+        body = [F.read(@path)]
+        size = Utils.bytesize(body.first)
+      end
+
+      [200, {
+        "Last-Modified"  => F.mtime(@path).httpdate,
+        "Content-Type"   => Mime.mime_type(F.extname(@path), 'text/plain'),
+        "Content-Length" => size.to_s
+      }, body]
+    end
+
+    def not_found
+      body = "File not found: #{@path_info}\n"
+      [404, {"Content-Type" => "text/plain",
+         "Content-Length" => body.size.to_s},
+       [body]]
+    end
+
+    def each
+      F.open(@path, "rb") { |file|
+        while part = file.read(8192)
+          yield part
+        end
+      }
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler.rb
new file mode 100644
index 0000000000..5624a1e79d
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler.rb
@@ -0,0 +1,69 @@
+module Rack
+  # *Handlers* connect web servers with Rack.
+  #
+  # Rack includes Handlers for Mongrel, WEBrick, FastCGI, CGI, SCGI
+  # and LiteSpeed.
+  #
+  # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
+  # A second optional hash can be passed to include server-specific
+  # configuration.
+  module Handler
+    def self.get(server)
+      return unless server
+      server = server.to_s
+
+      if klass = @handlers[server]
+        obj = Object
+        klass.split("::").each { |x| obj = obj.const_get(x) }
+        obj
+      else
+        try_require('rack/handler', server)
+        const_get(server)
+      end
+    end
+
+    # Transforms server-name constants to their canonical form as filenames,
+    # then tries to require them but silences the LoadError if not found
+    #
+    # Naming convention:
+    #
+    #   Foo # => 'foo'
+    #   FooBar # => 'foo_bar.rb'
+    #   FooBAR # => 'foobar.rb'
+    #   FOObar # => 'foobar.rb'
+    #   FOOBAR # => 'foobar.rb'
+    #   FooBarBaz # => 'foo_bar_baz.rb'
+    def self.try_require(prefix, const_name)
+      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
+        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
+
+      require(::File.join(prefix, file))
+    rescue LoadError
+    end
+
+    def self.register(server, klass)
+      @handlers ||= {}
+      @handlers[server] = klass
+    end
+
+    autoload :CGI, "rack/handler/cgi"
+    autoload :FastCGI, "rack/handler/fastcgi"
+    autoload :Mongrel, "rack/handler/mongrel"
+    autoload :EventedMongrel, "rack/handler/evented_mongrel"
+    autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel"
+    autoload :WEBrick, "rack/handler/webrick"
+    autoload :LSWS, "rack/handler/lsws"
+    autoload :SCGI, "rack/handler/scgi"
+    autoload :Thin, "rack/handler/thin"
+
+    register 'cgi', 'Rack::Handler::CGI'
+    register 'fastcgi', 'Rack::Handler::FastCGI'
+    register 'mongrel', 'Rack::Handler::Mongrel'
+    register 'emongrel', 'Rack::Handler::EventedMongrel'
+    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
+    register 'webrick', 'Rack::Handler::WEBrick'
+    register 'lsws', 'Rack::Handler::LSWS'
+    register 'scgi', 'Rack::Handler::SCGI'
+    register 'thin', 'Rack::Handler::Thin'
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/cgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/cgi.rb
new file mode 100644
index 0000000000..f45f3d735a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/cgi.rb
@@ -0,0 +1,61 @@
+require 'rack/content_length'
+
+module Rack
+  module Handler
+    class CGI
+      def self.run(app, options=nil)
+        serve app
+      end
+
+      def self.serve(app)
+        app = ContentLength.new(app)
+
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => $stdin,
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => true,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+
+      def self.send_headers(status, headers)
+        STDOUT.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            STDOUT.print "#{k}: #{v}\r\n"
+          }
+        }
+        STDOUT.print "\r\n"
+        STDOUT.flush
+      end
+
+      def self.send_body(body)
+        body.each { |part|
+          STDOUT.print part
+          STDOUT.flush
+        }
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/evented_mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/evented_mongrel.rb
new file mode 100644
index 0000000000..0f5cbf7293
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/evented_mongrel.rb
@@ -0,0 +1,8 @@
+require 'swiftcore/evented_mongrel'
+
+module Rack
+  module Handler
+    class EventedMongrel < Handler::Mongrel
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/fastcgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/fastcgi.rb
new file mode 100644
index 0000000000..11e1fcaa74
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/fastcgi.rb
@@ -0,0 +1,88 @@
+require 'fcgi'
+require 'socket'
+require 'rack/content_length'
+require 'rack/rewindable_input'
+
+class FCGI::Stream
+  alias _rack_read_without_buffer read
+
+  def read(n, buffer=nil)
+    buf = _rack_read_without_buffer n
+    buffer.replace(buf.to_s)  if buffer
+    buf
+  end
+end
+
+module Rack
+  module Handler
+    class FastCGI
+      def self.run(app, options={})
+        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
+        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
+        FCGI.each { |request|
+          serve request, app
+        }
+      end
+
+      def self.serve(request, app)
+        app = Rack::ContentLength.new(app)
+
+        env = request.env
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+        
+        rack_input = RewindableInput.new(request.in)
+
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => rack_input,
+                     "rack.errors" => request.err,
+
+                     "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"] == ""
+        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
+        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
+
+        begin
+          status, headers, body = app.call(env)
+          begin
+            send_headers request.out, status, headers
+            send_body request.out, body
+          ensure
+            body.close  if body.respond_to? :close
+          end
+        ensure
+          rack_input.close
+          request.finish
+        end
+      end
+
+      def self.send_headers(out, status, headers)
+        out.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            out.print "#{k}: #{v}\r\n"
+          }
+        }
+        out.print "\r\n"
+        out.flush
+      end
+
+      def self.send_body(out, body)
+        body.each { |part|
+          out.print part
+          out.flush
+        }
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/lsws.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/lsws.rb
new file mode 100644
index 0000000000..7231336d7b
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/lsws.rb
@@ -0,0 +1,55 @@
+require 'lsapi'
+require 'rack/content_length'
+
+module Rack
+  module Handler
+    class LSWS
+      def self.run(app, options=nil)
+        while LSAPI.accept != nil
+          serve app
+        end
+      end
+      def self.serve(app)
+        app = Rack::ContentLength.new(app)
+
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => StringIO.new($stdin.read.to_s),
+                     "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"] ||= "/"
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+      def self.send_headers(status, headers)
+        print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            print "#{k}: #{v}\r\n"
+          }
+        }
+        print "\r\n"
+        STDOUT.flush
+      end
+      def self.send_body(body)
+        body.each { |part|
+          print part
+          STDOUT.flush
+        }
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/mongrel.rb
new file mode 100644
index 0000000000..3a5ef32d4b
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/mongrel.rb
@@ -0,0 +1,84 @@
+require 'mongrel'
+require 'stringio'
+require 'rack/content_length'
+require 'rack/chunked'
+
+module Rack
+  module Handler
+    class Mongrel < ::Mongrel::HttpHandler
+      def self.run(app, options={})
+        server = ::Mongrel::HttpServer.new(options[:Host] || '0.0.0.0',
+                                           options[:Port] || 8080)
+        # Acts like Rack::URLMap, utilizing Mongrel's own path finding methods.
+        # Use is similar to #run, replacing the app argument with a hash of 
+        # { path=>app, ... } or an instance of Rack::URLMap.
+        if options[:map]
+          if app.is_a? Hash
+            app.each do |path, appl|
+              path = '/'+path unless path[0] == ?/
+              server.register(path, Rack::Handler::Mongrel.new(appl))
+            end
+          elsif app.is_a? URLMap
+            app.instance_variable_get(:@mapping).each do |(host, path, appl)|
+             next if !host.nil? && !options[:Host].nil? && options[:Host] != host
+             path = '/'+path unless path[0] == ?/
+             server.register(path, Rack::Handler::Mongrel.new(appl))
+            end
+          else
+            raise ArgumentError, "first argument should be a Hash or URLMap"
+          end
+        else
+          server.register('/', Rack::Handler::Mongrel.new(app))
+        end
+        yield server  if block_given?
+        server.run.join
+      end
+
+      def initialize(app)
+        @app = Rack::Chunked.new(Rack::ContentLength.new(app))
+      end
+
+      def process(request, response)
+        env = {}.replace(request.params)
+        env.delete "HTTP_CONTENT_TYPE"
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => request.body || StringIO.new(""),
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => false, # ???
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => "http",
+                   })
+        env["QUERY_STRING"] ||= ""
+        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+
+        status, headers, body = @app.call(env)
+
+        begin
+          response.status = status.to_i
+          response.send_status(nil)
+
+          headers.each { |k, vs|
+            vs.split("\n").each { |v|
+              response.header[k] = v
+            }
+          }
+          response.send_header
+
+          body.each { |part|
+            response.write part
+            response.socket.flush
+          }
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/scgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/scgi.rb
new file mode 100644
index 0000000000..6c4932df95
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/scgi.rb
@@ -0,0 +1,59 @@
+require 'scgi'
+require 'stringio'
+require 'rack/content_length'
+require 'rack/chunked'
+
+module Rack
+  module Handler
+    class SCGI < ::SCGI::Processor
+      attr_accessor :app
+      
+      def self.run(app, options=nil)
+        new(options.merge(:app=>app,
+                          :host=>options[:Host],
+                          :port=>options[:Port],
+                          :socket=>options[:Socket])).listen
+      end
+      
+      def initialize(settings = {})
+        @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
+        @log = Object.new
+        def @log.info(*args); end
+        def @log.error(*args); end
+        super(settings)
+      end
+        
+      def process_request(request, input_body, socket)
+        env = {}.replace(request)
+        env.delete "HTTP_CONTENT_TYPE"
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["REQUEST_PATH"], env["QUERY_STRING"] = env["REQUEST_URI"].split('?', 2)
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["PATH_INFO"] = env["REQUEST_PATH"]
+        env["QUERY_STRING"] ||= ""
+        env["SCRIPT_NAME"] = ""
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => StringIO.new(input_body),
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+                   })
+        status, headers, body = app.call(env)
+        begin
+          socket.write("Status: #{status}\r\n")
+          headers.each do |k, vs|
+            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
+          end
+          socket.write("\r\n")
+          body.each {|s| socket.write(s)}
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/swiftiplied_mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/swiftiplied_mongrel.rb
new file mode 100644
index 0000000000..4bafd0b953
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/swiftiplied_mongrel.rb
@@ -0,0 +1,8 @@
+require 'swiftcore/swiftiplied_mongrel'
+
+module Rack
+  module Handler
+    class SwiftipliedMongrel < Handler::Mongrel
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/thin.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/thin.rb
new file mode 100644
index 0000000000..3d4fedff75
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/thin.rb
@@ -0,0 +1,18 @@
+require "thin"
+require "rack/content_length"
+require "rack/chunked"
+
+module Rack
+  module Handler
+    class Thin
+      def self.run(app, options={})
+        app = Rack::Chunked.new(Rack::ContentLength.new(app))
+        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
+                                    options[:Port] || 8080,
+                                    app)
+        yield server if block_given?
+        server.start
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/webrick.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/webrick.rb
new file mode 100644
index 0000000000..2bdc83a9ff
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/webrick.rb
@@ -0,0 +1,67 @@
+require 'webrick'
+require 'stringio'
+require 'rack/content_length'
+
+module Rack
+  module Handler
+    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
+      def self.run(app, options={})
+        server = ::WEBrick::HTTPServer.new(options)
+        server.mount "/", Rack::Handler::WEBrick, app
+        trap(:INT) { server.shutdown }
+        yield server  if block_given?
+        server.start
+      end
+
+      def initialize(server, app)
+        super server
+        @app = Rack::ContentLength.new(app)
+      end
+
+      def service(req, res)
+        env = req.meta_vars
+        env.delete_if { |k, v| v.nil? }
+
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => StringIO.new(req.body.to_s),
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => false,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["QUERY_STRING"] ||= ""
+        env["REQUEST_PATH"] ||= "/"
+        if env["PATH_INFO"] == ""
+          env.delete "PATH_INFO"
+        else
+          path, n = req.request_uri.path, env["SCRIPT_NAME"].length
+          env["PATH_INFO"] = path[n, path.length-n]
+        end
+
+        status, headers, body = @app.call(env)
+        begin
+          res.status = status.to_i
+          headers.each { |k, vs|
+            if k.downcase == "set-cookie"
+              res.cookies.concat vs.split("\n")
+            else
+              vs.split("\n").each { |v|
+                res[k] = v
+              }
+            end
+          }
+          body.each { |part|
+            res.body << part
+          }
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/head.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/head.rb
new file mode 100644
index 0000000000..deab822a99
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/head.rb
@@ -0,0 +1,19 @@
+module Rack
+
+class Head
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    status, headers, body = @app.call(env)
+
+    if env["REQUEST_METHOD"] == "HEAD"
+      [status, headers, []]
+    else
+      [status, headers, body]
+    end
+  end
+end
+
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lint.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lint.rb
new file mode 100644
index 0000000000..bf2e9787a1
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lint.rb
@@ -0,0 +1,537 @@
+require 'rack/utils'
+
+module Rack
+  # Rack::Lint validates your application and the requests and
+  # responses according to the Rack spec.
+
+  class Lint
+    def initialize(app)
+      @app = app
+    end
+
+    # :stopdoc:
+
+    class LintError < RuntimeError; end
+    module Assertion
+      def assert(message, &block)
+        unless block.call
+          raise LintError, message
+        end
+      end
+    end
+    include Assertion
+
+    ## This specification aims to formalize the Rack protocol.  You
+    ## can (and should) use Rack::Lint to enforce it.
+    ##
+    ## When you develop middleware, be sure to add a Lint before and
+    ## after to catch all mistakes.
+
+    ## = Rack applications
+
+    ## A Rack application is an Ruby object (not a class) that
+    ## responds to +call+.
+    def call(env=nil)
+      dup._call(env)
+    end
+
+    def _call(env)
+      ## It takes exactly one argument, the *environment*
+      assert("No env given") { env }
+      check_env env
+
+      env['rack.input'] = InputWrapper.new(env['rack.input'])
+      env['rack.errors'] = ErrorWrapper.new(env['rack.errors'])
+
+      ## and returns an Array of exactly three values:
+      status, headers, @body = @app.call(env)
+      ## The *status*,
+      check_status status
+      ## the *headers*,
+      check_headers headers
+      ## and the *body*.
+      check_content_type status, headers
+      check_content_length status, headers, env
+      [status, headers, self]
+    end
+
+    ## == The Environment
+    def check_env(env)
+      ## The environment must be an true instance of Hash (no
+      ## subclassing allowed) that includes CGI-like headers.
+      ## The application is free to modify the environment.
+      assert("env #{env.inspect} is not a Hash, but #{env.class}") {
+        env.instance_of? Hash
+      }
+
+      ##
+      ## The environment is required to include these variables
+      ## (adopted from PEP333), except when they'd be empty, but see
+      ## below.
+
+      ## <tt>REQUEST_METHOD</tt>:: The HTTP request method, such as
+      ##                           "GET" or "POST". This cannot ever
+      ##                           be an empty string, and so is
+      ##                           always required.
+
+      ## <tt>SCRIPT_NAME</tt>:: The initial portion of the request
+      ##                        URL's "path" that corresponds to the
+      ##                        application object, so that the
+      ##                        application knows its virtual
+      ##                        "location". This may be an empty
+      ##                        string, if the application corresponds
+      ##                        to the "root" of the server.
+
+      ## <tt>PATH_INFO</tt>:: The remainder of the request URL's
+      ##                      "path", designating the virtual
+      ##                      "location" of the request's target
+      ##                      within the application. This may be an
+      ##                      empty string, if the request URL targets
+      ##                      the application root and does not have a
+      ##                      trailing slash. This value may be
+      ##                      percent-encoded when I originating from
+      ##                      a URL.
+
+      ## <tt>QUERY_STRING</tt>:: The portion of the request URL that
+      ##                         follows the <tt>?</tt>, if any. May be
+      ##                         empty, but is always required!
+
+      ## <tt>SERVER_NAME</tt>, <tt>SERVER_PORT</tt>:: When combined with <tt>SCRIPT_NAME</tt> and <tt>PATH_INFO</tt>, these variables can be used to complete the URL. Note, however, that <tt>HTTP_HOST</tt>, if present, should be used in preference to <tt>SERVER_NAME</tt> for reconstructing the request URL.  <tt>SERVER_NAME</tt> and <tt>SERVER_PORT</tt> can never be empty strings, and so are always required.
+
+      ## <tt>HTTP_</tt> Variables:: Variables corresponding to the
+      ##                            client-supplied HTTP request
+      ##                            headers (i.e., variables whose
+      ##                            names begin with <tt>HTTP_</tt>). The
+      ##                            presence or absence of these
+      ##                            variables should correspond with
+      ##                            the presence or absence of the
+      ##                            appropriate HTTP header in the
+      ##                            request.
+
+      ## In addition to this, the Rack environment must include these
+      ## Rack-specific variables:
+
+      ## <tt>rack.version</tt>:: The Array [1,0], representing this version of Rack.
+      ## <tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the request URL.
+      ## <tt>rack.input</tt>:: See below, the input stream.
+      ## <tt>rack.errors</tt>:: See below, the error stream.
+      ## <tt>rack.multithread</tt>:: true if the application object may be simultaneously invoked by another thread in the same process, false otherwise.
+      ## <tt>rack.multiprocess</tt>:: true if an equivalent application object may be simultaneously invoked by another process, false otherwise.
+      ## <tt>rack.run_once</tt>:: true if the server expects (but does not guarantee!) that the application will only be invoked this one time during the life of its containing process. Normally, this will only be true for a server based on CGI (or something similar).
+      ##
+
+      ## Additional environment specifications have approved to
+      ## standardized middleware APIs.  None of these are required to
+      ## be implemented by the server.
+
+      ## <tt>rack.session</tt>:: A hash like interface for storing request session data.
+      ##                         The store must implement:
+      if session = env['rack.session']
+        ##                         store(key, value)         (aliased as []=);
+        assert("session #{session.inspect} must respond to store and []=") {
+          session.respond_to?(:store) && session.respond_to?(:[]=)
+        }
+
+        ##                         fetch(key, default = nil) (aliased as []);
+        assert("session #{session.inspect} must respond to fetch and []") {
+          session.respond_to?(:fetch) && session.respond_to?(:[])
+        }
+
+        ##                         delete(key);
+        assert("session #{session.inspect} must respond to delete") {
+          session.respond_to?(:delete)
+        }
+
+        ##                         clear;
+        assert("session #{session.inspect} must respond to clear") {
+          session.respond_to?(:clear)
+        }
+      end
+
+      ## The server or the application can store their own data in the
+      ## environment, too.  The keys must contain at least one dot,
+      ## and should be prefixed uniquely.  The prefix <tt>rack.</tt>
+      ## is reserved for use with the Rack core distribution and other
+      ## accepted specifications and must not be used otherwise.
+      ##
+
+      %w[REQUEST_METHOD SERVER_NAME SERVER_PORT
+         QUERY_STRING
+         rack.version rack.input rack.errors
+         rack.multithread rack.multiprocess rack.run_once].each { |header|
+        assert("env missing required key #{header}") { env.include? header }
+      }
+
+      ## The environment must not contain the keys
+      ## <tt>HTTP_CONTENT_TYPE</tt> or <tt>HTTP_CONTENT_LENGTH</tt>
+      ## (use the versions without <tt>HTTP_</tt>).
+      %w[HTTP_CONTENT_TYPE HTTP_CONTENT_LENGTH].each { |header|
+        assert("env contains #{header}, must use #{header[5,-1]}") {
+          not env.include? header
+        }
+      }
+
+      ## The CGI keys (named without a period) must have String values.
+      env.each { |key, value|
+        next  if key.include? "."   # Skip extensions
+        assert("env variable #{key} has non-string value #{value.inspect}") {
+          value.instance_of? String
+        }
+      }
+
+      ##
+      ## There are the following restrictions:
+
+      ## * <tt>rack.version</tt> must be an array of Integers.
+      assert("rack.version must be an Array, was #{env["rack.version"].class}") {
+        env["rack.version"].instance_of? Array
+      }
+      ## * <tt>rack.url_scheme</tt> must either be +http+ or +https+.
+      assert("rack.url_scheme unknown: #{env["rack.url_scheme"].inspect}") {
+        %w[http https].include? env["rack.url_scheme"]
+      }
+
+      ## * There must be a valid input stream in <tt>rack.input</tt>.
+      check_input env["rack.input"]
+      ## * There must be a valid error stream in <tt>rack.errors</tt>.
+      check_error env["rack.errors"]
+
+      ## * The <tt>REQUEST_METHOD</tt> must be a valid token.
+      assert("REQUEST_METHOD unknown: #{env["REQUEST_METHOD"]}") {
+        env["REQUEST_METHOD"] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/
+      }
+
+      ## * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt>
+      assert("SCRIPT_NAME must start with /") {
+        !env.include?("SCRIPT_NAME") ||
+        env["SCRIPT_NAME"] == "" ||
+        env["SCRIPT_NAME"] =~ /\A\//
+      }
+      ## * The <tt>PATH_INFO</tt>, if non-empty, must start with <tt>/</tt>
+      assert("PATH_INFO must start with /") {
+        !env.include?("PATH_INFO") ||
+        env["PATH_INFO"] == "" ||
+        env["PATH_INFO"] =~ /\A\//
+      }
+      ## * The <tt>CONTENT_LENGTH</tt>, if given, must consist of digits only.
+      assert("Invalid CONTENT_LENGTH: #{env["CONTENT_LENGTH"]}") {
+        !env.include?("CONTENT_LENGTH") || env["CONTENT_LENGTH"] =~ /\A\d+\z/
+      }
+
+      ## * One of <tt>SCRIPT_NAME</tt> or <tt>PATH_INFO</tt> must be
+      ##   set.  <tt>PATH_INFO</tt> should be <tt>/</tt> if
+      ##   <tt>SCRIPT_NAME</tt> is empty.
+      assert("One of SCRIPT_NAME or PATH_INFO must be set (make PATH_INFO '/' if SCRIPT_NAME is empty)") {
+        env["SCRIPT_NAME"] || env["PATH_INFO"]
+      }
+      ##   <tt>SCRIPT_NAME</tt> never should be <tt>/</tt>, but instead be empty.
+      assert("SCRIPT_NAME cannot be '/', make it '' and PATH_INFO '/'") {
+        env["SCRIPT_NAME"] != "/"
+      }
+    end
+
+    ## === The Input Stream
+    ##
+    ## The input stream is an IO-like object which contains the raw HTTP
+    ## POST data. If it is a file then it must be opened in binary mode.
+    def check_input(input)
+      ## The input stream must respond to +gets+, +each+, +read+ and +rewind+.
+      [:gets, :each, :read, :rewind].each { |method|
+        assert("rack.input #{input} does not respond to ##{method}") {
+          input.respond_to? method
+        }
+      }
+    end
+
+    class InputWrapper
+      include Assertion
+
+      def initialize(input)
+        @input = input
+      end
+
+      def size
+        @input.size
+      end
+
+      ## * +gets+ must be called without arguments and return a string,
+      ##   or +nil+ on EOF.
+      def gets(*args)
+        assert("rack.input#gets called with arguments") { args.size == 0 }
+        v = @input.gets
+        assert("rack.input#gets didn't return a String") {
+          v.nil? or v.instance_of? String
+        }
+        v
+      end
+
+      ## * +read+ behaves like IO#read. Its signature is <tt>read([length, [buffer]])</tt>.
+      ##   If given, +length+ must be an non-negative Integer (>= 0) or +nil+, and +buffer+ must
+      ##   be a String and may not be nil. If +length+ is given and not nil, then this method
+      ##   reads at most +length+ bytes from the input stream. If +length+ is not given or nil,
+      ##   then this method reads all data until EOF.
+      ##   When EOF is reached, this method returns nil if +length+ is given and not nil, or ""
+      ##   if +length+ is not given or is nil.
+      ##   If +buffer+ is given, then the read data will be placed into +buffer+ instead of a
+      ##   newly created String object.
+      def read(*args)
+        assert("rack.input#read called with too many arguments") {
+          args.size <= 2
+        }
+        if args.size >= 1
+          assert("rack.input#read called with non-integer and non-nil length") {
+            args.first.kind_of?(Integer) || args.first.nil?
+          }
+          assert("rack.input#read called with a negative length") {
+            args.first.nil? || args.first >= 0
+          }
+        end
+        if args.size >= 2
+          assert("rack.input#read called with non-String buffer") {
+            args[1].kind_of?(String)
+          }
+        end
+        
+        v = @input.read(*args)
+        
+        assert("rack.input#read didn't return nil or a String") {
+          v.nil? or v.instance_of? String
+        }
+        if args[0].nil?
+          assert("rack.input#read(nil) returned nil on EOF") {
+            !v.nil?
+          }
+        end
+        
+        v
+      end
+
+      ## * +each+ must be called without arguments and only yield Strings.
+      def each(*args)
+        assert("rack.input#each called with arguments") { args.size == 0 }
+        @input.each { |line|
+          assert("rack.input#each didn't yield a String") {
+            line.instance_of? String
+          }
+          yield line
+        }
+      end
+      
+      ## * +rewind+ must be called without arguments. It rewinds the input
+      ##   stream back to the beginning. It must not raise Errno::ESPIPE:
+      ##   that is, it may not be a pipe or a socket. Therefore, handler
+      ##   developers must buffer the input data into some rewindable object
+      ##   if the underlying input stream is not rewindable.
+      def rewind(*args)
+        assert("rack.input#rewind called with arguments") { args.size == 0 }
+        assert("rack.input#rewind raised Errno::ESPIPE") {
+          begin
+            @input.rewind
+            true
+          rescue Errno::ESPIPE
+            false
+          end
+        }
+      end
+
+      ## * +close+ must never be called on the input stream.
+      def close(*args)
+        assert("rack.input#close must not be called") { false }
+      end
+    end
+
+    ## === The Error Stream
+    def check_error(error)
+      ## The error stream must respond to +puts+, +write+ and +flush+.
+      [:puts, :write, :flush].each { |method|
+        assert("rack.error #{error} does not respond to ##{method}") {
+          error.respond_to? method
+        }
+      }
+    end
+
+    class ErrorWrapper
+      include Assertion
+
+      def initialize(error)
+        @error = error
+      end
+
+      ## * +puts+ must be called with a single argument that responds to +to_s+.
+      def puts(str)
+        @error.puts str
+      end
+
+      ## * +write+ must be called with a single argument that is a String.
+      def write(str)
+        assert("rack.errors#write not called with a String") { str.instance_of? String }
+        @error.write str
+      end
+
+      ## * +flush+ must be called without arguments and must be called
+      ##   in order to make the error appear for sure.
+      def flush
+        @error.flush
+      end
+
+      ## * +close+ must never be called on the error stream.
+      def close(*args)
+        assert("rack.errors#close must not be called") { false }
+      end
+    end
+
+    ## == The Response
+
+    ## === The Status
+    def check_status(status)
+      ## This is an HTTP status. When parsed as integer (+to_i+), it must be
+      ## greater than or equal to 100.
+      assert("Status must be >=100 seen as integer") { status.to_i >= 100 }
+    end
+
+    ## === The Headers
+    def check_headers(header)
+      ## The header must respond to +each+, and yield values of key and value.
+      assert("headers object should respond to #each, but doesn't (got #{header.class} as headers)") {
+         header.respond_to? :each
+      }
+      header.each { |key, value|
+        ## The header keys must be Strings.
+        assert("header key must be a string, was #{key.class}") {
+          key.instance_of? String
+        }
+        ## The header must not contain a +Status+ key,
+        assert("header must not contain Status") { key.downcase != "status" }
+        ## contain keys with <tt>:</tt> or newlines in their name,
+        assert("header names must not contain : or \\n") { key !~ /[:\n]/ }
+        ## contain keys names that end in <tt>-</tt> or <tt>_</tt>,
+        assert("header names must not end in - or _") { key !~ /[-_]\z/ }
+        ## but only contain keys that consist of
+        ## letters, digits, <tt>_</tt> or <tt>-</tt> and start with a letter.
+        assert("invalid header name: #{key}") { key =~ /\A[a-zA-Z][a-zA-Z0-9_-]*\z/ }
+
+        ## The values of the header must be Strings,
+        assert("a header value must be a String, but the value of " +
+          "'#{key}' is a #{value.class}") { value.kind_of? String }
+        ## consisting of lines (for multiple header values, e.g. multiple
+        ## <tt>Set-Cookie</tt> values) seperated by "\n".
+        value.split("\n").each { |item|
+          ## The lines must not contain characters below 037.
+          assert("invalid header value #{key}: #{item.inspect}") {
+            item !~ /[\000-\037]/
+          }
+        }
+      }
+    end
+
+    ## === The Content-Type
+    def check_content_type(status, headers)
+      headers.each { |key, value|
+        ## There must be a <tt>Content-Type</tt>, except when the
+        ## +Status+ is 1xx, 204 or 304, in which case there must be none
+        ## given.
+        if key.downcase == "content-type"
+          assert("Content-Type header found in #{status} response, not allowed") {
+            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
+          }
+          return
+        end
+      }
+      assert("No Content-Type header found") {
+        Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
+      }
+    end
+
+    ## === The Content-Length
+    def check_content_length(status, headers, env)
+      headers.each { |key, value|
+        if key.downcase == 'content-length'
+          ## There must not be a <tt>Content-Length</tt> header when the
+          ## +Status+ is 1xx, 204 or 304.
+          assert("Content-Length header found in #{status} response, not allowed") {
+            not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
+          }
+
+          bytes = 0
+          string_body = true
+
+          if @body.respond_to?(:to_ary)
+            @body.each { |part|
+              unless part.kind_of?(String)
+                string_body = false
+                break
+              end
+
+              bytes += Rack::Utils.bytesize(part)
+            }
+
+            if env["REQUEST_METHOD"] == "HEAD"
+              assert("Response body was given for HEAD request, but should be empty") {
+                bytes == 0
+              }
+            else
+              if string_body
+                assert("Content-Length header was #{value}, but should be #{bytes}") {
+                  value == bytes.to_s
+                }
+              end
+            end
+          end
+
+          return
+        end
+      }
+    end
+
+    ## === The Body
+    def each
+      @closed = false
+      ## The Body must respond to +each+
+      @body.each { |part|
+        ## and must only yield String values.
+        assert("Body yielded non-string value #{part.inspect}") {
+          part.instance_of? String
+        }
+        yield part
+      }
+      ##
+      ## The Body itself should not be an instance of String, as this will
+      ## break in Ruby 1.9.
+      ##
+      ## If the Body responds to +close+, it will be called after iteration.
+      # XXX howto: assert("Body has not been closed") { @closed }
+
+
+      ##
+      ## If the Body responds to +to_path+, it must return a String
+      ## identifying the location of a file whose contents are identical
+      ## to that produced by calling +each+; this may be used by the
+      ## server as an alternative, possibly more efficient way to
+      ## transport the response.
+
+      if @body.respond_to?(:to_path)
+        assert("The file identified by body.to_path does not exist") {
+          ::File.exist? @body.to_path
+        }
+      end
+
+      ##
+      ## The Body commonly is an Array of Strings, the application
+      ## instance itself, or a File-like object.
+    end
+
+    def close
+      @closed = true
+      @body.close  if @body.respond_to?(:close)
+    end
+
+    # :startdoc:
+
+  end
+end
+
+## == Thanks
+## Some parts of this specification are adopted from PEP333: Python
+## Web Server Gateway Interface
+## v1.0 (http://www.python.org/dev/peps/pep-0333/). I'd like to thank
+## everyone involved in that effort.
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lobster.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lobster.rb
new file mode 100644
index 0000000000..f63f419a49
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lobster.rb
@@ -0,0 +1,65 @@
+require 'zlib'
+
+require 'rack/request'
+require 'rack/response'
+
+module Rack
+  # Paste has a Pony, Rack has a Lobster!
+  class Lobster
+    LobsterString = Zlib::Inflate.inflate("eJx9kEEOwyAMBO99xd7MAcytUhPlJyj2
+    P6jy9i4k9EQyGAnBarEXeCBqSkntNXsi/ZCvC48zGQoZKikGrFMZvgS5ZHd+aGWVuWwhVF0
+    t1drVmiR42HcWNz5w3QanT+2gIvTVCiE1lm1Y0eU4JGmIIbaKwextKn8rvW+p5PIwFl8ZWJ
+    I8jyiTlhTcYXkekJAzTyYN6E08A+dk8voBkAVTJQ==".delete("\n ").unpack("m*")[0])
+
+    LambdaLobster = lambda { |env|
+      if env["QUERY_STRING"].include?("flip")
+        lobster = LobsterString.split("\n").
+          map { |line| line.ljust(42).reverse }.
+          join("\n")
+        href = "?"
+      else
+        lobster = LobsterString
+        href = "?flip"
+      end
+
+      content = ["<title>Lobstericious!</title>",
+                 "<pre>", lobster, "</pre>",
+                 "<a href='#{href}'>flip!</a>"]
+      length = content.inject(0) { |a,e| a+e.size }.to_s
+      [200, {"Content-Type" => "text/html", "Content-Length" => length}, content]
+    }
+
+    def call(env)
+      req = Request.new(env)
+      if req.GET["flip"] == "left"
+        lobster = LobsterString.split("\n").
+          map { |line| line.ljust(42).reverse }.
+          join("\n")
+        href = "?flip=right"
+      elsif req.GET["flip"] == "crash"
+        raise "Lobster crashed"
+      else
+        lobster = LobsterString
+        href = "?flip=left"
+      end
+
+      res = Response.new
+      res.write "<title>Lobstericious!</title>"
+      res.write "<pre>"
+      res.write lobster
+      res.write "</pre>"
+      res.write "<p><a href='#{href}'>flip!</a></p>"
+      res.write "<p><a href='?flip=crash'>crash!</a></p>"
+      res.finish
+    end
+
+  end
+end
+
+if $0 == __FILE__
+  require 'rack'
+  require 'rack/showexceptions'
+  Rack::Handler::WEBrick.run \
+    Rack::ShowExceptions.new(Rack::Lint.new(Rack::Lobster.new)),
+    :Port => 9292
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lock.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lock.rb
new file mode 100644
index 0000000000..93238528c4
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lock.rb
@@ -0,0 +1,16 @@
+module Rack
+  class Lock
+    FLAG = 'rack.multithread'.freeze
+
+    def initialize(app, lock = Mutex.new)
+      @app, @lock = app, lock
+    end
+
+    def call(env)
+      old, env[FLAG] = env[FLAG], false
+      @lock.synchronize { @app.call(env) }
+    ensure
+      env[FLAG] = old
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/methodoverride.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/methodoverride.rb
new file mode 100644
index 0000000000..0eed29f471
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/methodoverride.rb
@@ -0,0 +1,27 @@
+module Rack
+  class MethodOverride
+    HTTP_METHODS = %w(GET HEAD PUT POST DELETE OPTIONS)
+
+    METHOD_OVERRIDE_PARAM_KEY = "_method".freeze
+    HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE".freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["REQUEST_METHOD"] == "POST"
+        req = Request.new(env)
+        method = req.POST[METHOD_OVERRIDE_PARAM_KEY] ||
+          env[HTTP_METHOD_OVERRIDE_HEADER]
+        method = method.to_s.upcase
+        if HTTP_METHODS.include?(method)
+          env["rack.methodoverride.original_method"] = env["REQUEST_METHOD"]
+          env["REQUEST_METHOD"] = method
+        end
+      end
+
+      @app.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mime.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mime.rb
new file mode 100644
index 0000000000..5a6a73a97b
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mime.rb
@@ -0,0 +1,204 @@
+module Rack
+  module Mime
+    # Returns String with mime type if found, otherwise use +fallback+.
+    # +ext+ should be filename extension in the '.ext' format that
+    #       File.extname(file) returns.
+    # +fallback+ may be any object
+    #
+    # Also see the documentation for MIME_TYPES
+    #
+    # Usage:
+    #     Rack::Mime.mime_type('.foo')
+    #
+    # This is a shortcut for:
+    #     Rack::Mime::MIME_TYPES.fetch('.foo', 'application/octet-stream')
+
+    def mime_type(ext, fallback='application/octet-stream')
+      MIME_TYPES.fetch(ext, fallback)
+    end
+    module_function :mime_type
+
+    # List of most common mime-types, selected various sources
+    # according to their usefulness in a webserving scope for Ruby
+    # users.
+    #
+    # To amend this list with your local mime.types list you can use:
+    #
+    #     require 'webrick/httputils'
+    #     list = WEBrick::HTTPUtils.load_mime_types('/etc/mime.types')
+    #     Rack::Mime::MIME_TYPES.merge!(list)
+    #
+    # To add the list mongrel provides, use:
+    #
+    #     require 'mongrel/handlers'
+    #     Rack::Mime::MIME_TYPES.merge!(Mongrel::DirHandler::MIME_TYPES)
+
+    MIME_TYPES = {
+      ".3gp"     => "video/3gpp",
+      ".a"       => "application/octet-stream",
+      ".ai"      => "application/postscript",
+      ".aif"     => "audio/x-aiff",
+      ".aiff"    => "audio/x-aiff",
+      ".asc"     => "application/pgp-signature",
+      ".asf"     => "video/x-ms-asf",
+      ".asm"     => "text/x-asm",
+      ".asx"     => "video/x-ms-asf",
+      ".atom"    => "application/atom+xml",
+      ".au"      => "audio/basic",
+      ".avi"     => "video/x-msvideo",
+      ".bat"     => "application/x-msdownload",
+      ".bin"     => "application/octet-stream",
+      ".bmp"     => "image/bmp",
+      ".bz2"     => "application/x-bzip2",
+      ".c"       => "text/x-c",
+      ".cab"     => "application/vnd.ms-cab-compressed",
+      ".cc"      => "text/x-c",
+      ".chm"     => "application/vnd.ms-htmlhelp",
+      ".class"   => "application/octet-stream",
+      ".com"     => "application/x-msdownload",
+      ".conf"    => "text/plain",
+      ".cpp"     => "text/x-c",
+      ".crt"     => "application/x-x509-ca-cert",
+      ".css"     => "text/css",
+      ".csv"     => "text/csv",
+      ".cxx"     => "text/x-c",
+      ".deb"     => "application/x-debian-package",
+      ".der"     => "application/x-x509-ca-cert",
+      ".diff"    => "text/x-diff",
+      ".djv"     => "image/vnd.djvu",
+      ".djvu"    => "image/vnd.djvu",
+      ".dll"     => "application/x-msdownload",
+      ".dmg"     => "application/octet-stream",
+      ".doc"     => "application/msword",
+      ".dot"     => "application/msword",
+      ".dtd"     => "application/xml-dtd",
+      ".dvi"     => "application/x-dvi",
+      ".ear"     => "application/java-archive",
+      ".eml"     => "message/rfc822",
+      ".eps"     => "application/postscript",
+      ".exe"     => "application/x-msdownload",
+      ".f"       => "text/x-fortran",
+      ".f77"     => "text/x-fortran",
+      ".f90"     => "text/x-fortran",
+      ".flv"     => "video/x-flv",
+      ".for"     => "text/x-fortran",
+      ".gem"     => "application/octet-stream",
+      ".gemspec" => "text/x-script.ruby",
+      ".gif"     => "image/gif",
+      ".gz"      => "application/x-gzip",
+      ".h"       => "text/x-c",
+      ".hh"      => "text/x-c",
+      ".htm"     => "text/html",
+      ".html"    => "text/html",
+      ".ico"     => "image/vnd.microsoft.icon",
+      ".ics"     => "text/calendar",
+      ".ifb"     => "text/calendar",
+      ".iso"     => "application/octet-stream",
+      ".jar"     => "application/java-archive",
+      ".java"    => "text/x-java-source",
+      ".jnlp"    => "application/x-java-jnlp-file",
+      ".jpeg"    => "image/jpeg",
+      ".jpg"     => "image/jpeg",
+      ".js"      => "application/javascript",
+      ".json"    => "application/json",
+      ".log"     => "text/plain",
+      ".m3u"     => "audio/x-mpegurl",
+      ".m4v"     => "video/mp4",
+      ".man"     => "text/troff",
+      ".mathml"  => "application/mathml+xml",
+      ".mbox"    => "application/mbox",
+      ".mdoc"    => "text/troff",
+      ".me"      => "text/troff",
+      ".mid"     => "audio/midi",
+      ".midi"    => "audio/midi",
+      ".mime"    => "message/rfc822",
+      ".mml"     => "application/mathml+xml",
+      ".mng"     => "video/x-mng",
+      ".mov"     => "video/quicktime",
+      ".mp3"     => "audio/mpeg",
+      ".mp4"     => "video/mp4",
+      ".mp4v"    => "video/mp4",
+      ".mpeg"    => "video/mpeg",
+      ".mpg"     => "video/mpeg",
+      ".ms"      => "text/troff",
+      ".msi"     => "application/x-msdownload",
+      ".odp"     => "application/vnd.oasis.opendocument.presentation",
+      ".ods"     => "application/vnd.oasis.opendocument.spreadsheet",
+      ".odt"     => "application/vnd.oasis.opendocument.text",
+      ".ogg"     => "application/ogg",
+      ".p"       => "text/x-pascal",
+      ".pas"     => "text/x-pascal",
+      ".pbm"     => "image/x-portable-bitmap",
+      ".pdf"     => "application/pdf",
+      ".pem"     => "application/x-x509-ca-cert",
+      ".pgm"     => "image/x-portable-graymap",
+      ".pgp"     => "application/pgp-encrypted",
+      ".pkg"     => "application/octet-stream",
+      ".pl"      => "text/x-script.perl",
+      ".pm"      => "text/x-script.perl-module",
+      ".png"     => "image/png",
+      ".pnm"     => "image/x-portable-anymap",
+      ".ppm"     => "image/x-portable-pixmap",
+      ".pps"     => "application/vnd.ms-powerpoint",
+      ".ppt"     => "application/vnd.ms-powerpoint",
+      ".ps"      => "application/postscript",
+      ".psd"     => "image/vnd.adobe.photoshop",
+      ".py"      => "text/x-script.python",
+      ".qt"      => "video/quicktime",
+      ".ra"      => "audio/x-pn-realaudio",
+      ".rake"    => "text/x-script.ruby",
+      ".ram"     => "audio/x-pn-realaudio",
+      ".rar"     => "application/x-rar-compressed",
+      ".rb"      => "text/x-script.ruby",
+      ".rdf"     => "application/rdf+xml",
+      ".roff"    => "text/troff",
+      ".rpm"     => "application/x-redhat-package-manager",
+      ".rss"     => "application/rss+xml",
+      ".rtf"     => "application/rtf",
+      ".ru"      => "text/x-script.ruby",
+      ".s"       => "text/x-asm",
+      ".sgm"     => "text/sgml",
+      ".sgml"    => "text/sgml",
+      ".sh"      => "application/x-sh",
+      ".sig"     => "application/pgp-signature",
+      ".snd"     => "audio/basic",
+      ".so"      => "application/octet-stream",
+      ".svg"     => "image/svg+xml",
+      ".svgz"    => "image/svg+xml",
+      ".swf"     => "application/x-shockwave-flash",
+      ".t"       => "text/troff",
+      ".tar"     => "application/x-tar",
+      ".tbz"     => "application/x-bzip-compressed-tar",
+      ".tcl"     => "application/x-tcl",
+      ".tex"     => "application/x-tex",
+      ".texi"    => "application/x-texinfo",
+      ".texinfo" => "application/x-texinfo",
+      ".text"    => "text/plain",
+      ".tif"     => "image/tiff",
+      ".tiff"    => "image/tiff",
+      ".torrent" => "application/x-bittorrent",
+      ".tr"      => "text/troff",
+      ".txt"     => "text/plain",
+      ".vcf"     => "text/x-vcard",
+      ".vcs"     => "text/x-vcalendar",
+      ".vrml"    => "model/vrml",
+      ".war"     => "application/java-archive",
+      ".wav"     => "audio/x-wav",
+      ".wma"     => "audio/x-ms-wma",
+      ".wmv"     => "video/x-ms-wmv",
+      ".wmx"     => "video/x-ms-wmx",
+      ".wrl"     => "model/vrml",
+      ".wsdl"    => "application/wsdl+xml",
+      ".xbm"     => "image/x-xbitmap",
+      ".xhtml"   => "application/xhtml+xml",
+      ".xls"     => "application/vnd.ms-excel",
+      ".xml"     => "application/xml",
+      ".xpm"     => "image/x-xpixmap",
+      ".xsl"     => "application/xml",
+      ".xslt"    => "application/xslt+xml",
+      ".yaml"    => "text/yaml",
+      ".yml"     => "text/yaml",
+      ".zip"     => "application/zip",
+    }
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mock.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mock.rb
new file mode 100644
index 0000000000..fdefb0340a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mock.rb
@@ -0,0 +1,184 @@
+require 'uri'
+require 'stringio'
+require 'rack/lint'
+require 'rack/utils'
+require 'rack/response'
+
+module Rack
+  # Rack::MockRequest helps testing your Rack application without
+  # actually using HTTP.
+  #
+  # After performing a request on a URL with get/post/put/delete, it
+  # returns a MockResponse with useful helper methods for effective
+  # testing.
+  #
+  # You can pass a hash with additional configuration to the
+  # get/post/put/delete.
+  # <tt>:input</tt>:: A String or IO-like to be used as rack.input.
+  # <tt>:fatal</tt>:: Raise a FatalWarning if the app writes to rack.errors.
+  # <tt>:lint</tt>:: If true, wrap the application in a Rack::Lint.
+
+  class MockRequest
+    class FatalWarning < RuntimeError
+    end
+
+    class FatalWarner
+      def puts(warning)
+        raise FatalWarning, warning
+      end
+
+      def write(warning)
+        raise FatalWarning, warning
+      end
+
+      def flush
+      end
+
+      def string
+        ""
+      end
+    end
+
+    DEFAULT_ENV = {
+      "rack.version" => [1,0],
+      "rack.input" => StringIO.new,
+      "rack.errors" => StringIO.new,
+      "rack.multithread" => true,
+      "rack.multiprocess" => true,
+      "rack.run_once" => false,
+    }
+
+    def initialize(app)
+      @app = app
+    end
+
+    def get(uri, opts={})    request("GET", uri, opts)    end
+    def post(uri, opts={})   request("POST", uri, opts)   end
+    def put(uri, opts={})    request("PUT", uri, opts)    end
+    def delete(uri, opts={}) request("DELETE", uri, opts) end
+
+    def request(method="GET", uri="", opts={})
+      env = self.class.env_for(uri, opts.merge(:method => method))
+
+      if opts[:lint]
+        app = Rack::Lint.new(@app)
+      else
+        app = @app
+      end
+
+      errors = env["rack.errors"]
+      MockResponse.new(*(app.call(env) + [errors]))
+    end
+
+    # Return the Rack environment used for a request to +uri+.
+    def self.env_for(uri="", opts={})
+      uri = URI(uri)
+      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
+
+      env = DEFAULT_ENV.dup
+
+      env["REQUEST_METHOD"] = opts[:method] ? opts[:method].to_s.upcase : "GET"
+      env["SERVER_NAME"] = uri.host || "example.org"
+      env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
+      env["QUERY_STRING"] = uri.query.to_s
+      env["PATH_INFO"] = (!uri.path || uri.path.empty?) ? "/" : uri.path
+      env["rack.url_scheme"] = uri.scheme || "http"
+      env["HTTPS"] = env["rack.url_scheme"] == "https" ? "on" : "off"
+
+      env["SCRIPT_NAME"] = opts[:script_name] || ""
+
+      if opts[:fatal]
+        env["rack.errors"] = FatalWarner.new
+      else
+        env["rack.errors"] = StringIO.new
+      end
+
+      if params = opts[:params]
+        if env["REQUEST_METHOD"] == "GET"
+          params = Utils.parse_nested_query(params) if params.is_a?(String)
+          params.update(Utils.parse_nested_query(env["QUERY_STRING"]))
+          env["QUERY_STRING"] = Utils.build_nested_query(params)
+        elsif !opts.has_key?(:input)
+          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+          if params.is_a?(Hash)
+            if data = Utils::Multipart.build_multipart(params)
+              opts[:input] = data
+              opts["CONTENT_LENGTH"] ||= data.length.to_s
+              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Utils::Multipart::MULTIPART_BOUNDARY}"
+            else
+              opts[:input] = Utils.build_nested_query(params)
+            end
+          else
+            opts[:input] = params
+          end
+        end
+      end
+
+      opts[:input] ||= ""
+      if String === opts[:input]
+        env["rack.input"] = StringIO.new(opts[:input])
+      else
+        env["rack.input"] = opts[:input]
+      end
+
+      env["CONTENT_LENGTH"] ||= env["rack.input"].length.to_s
+
+      opts.each { |field, value|
+        env[field] = value  if String === field
+      }
+
+      env
+    end
+  end
+
+  # Rack::MockResponse provides useful helpers for testing your apps.
+  # Usually, you don't create the MockResponse on your own, but use
+  # MockRequest.
+
+  class MockResponse
+    def initialize(status, headers, body, errors=StringIO.new(""))
+      @status = status.to_i
+
+      @original_headers = headers
+      @headers = Rack::Utils::HeaderHash.new
+      headers.each { |field, values|
+        @headers[field] = values
+        @headers[field] = ""  if values.empty?
+      }
+
+      @body = ""
+      body.each { |part| @body << part }
+
+      @errors = errors.string if errors.respond_to?(:string)
+    end
+
+    # Status
+    attr_reader :status
+
+    # Headers
+    attr_reader :headers, :original_headers
+
+    def [](field)
+      headers[field]
+    end
+
+
+    # Body
+    attr_reader :body
+
+    def =~(other)
+      @body =~ other
+    end
+
+    def match(other)
+      @body.match other
+    end
+
+
+    # Errors
+    attr_accessor :errors
+
+
+    include Response::Helpers
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/recursive.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/recursive.rb
new file mode 100644
index 0000000000..bf8b965925
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/recursive.rb
@@ -0,0 +1,57 @@
+require 'uri'
+
+module Rack
+  # Rack::ForwardRequest gets caught by Rack::Recursive and redirects
+  # the current request to the app at +url+.
+  #
+  #   raise ForwardRequest.new("/not-found")
+  #
+
+  class ForwardRequest < Exception
+    attr_reader :url, :env
+
+    def initialize(url, env={})
+      @url = URI(url)
+      @env = env
+
+      @env["PATH_INFO"] =       @url.path
+      @env["QUERY_STRING"] =    @url.query  if @url.query
+      @env["HTTP_HOST"] =       @url.host   if @url.host
+      @env["HTTP_PORT"] =       @url.port   if @url.port
+      @env["rack.url_scheme"] = @url.scheme if @url.scheme
+
+      super "forwarding to #{url}"
+    end
+  end
+
+  # Rack::Recursive allows applications called down the chain to
+  # include data from other applications (by using
+  # <tt>rack['rack.recursive.include'][...]</tt> or raise a
+  # ForwardRequest to redirect internally.
+
+  class Recursive
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @script_name = env["SCRIPT_NAME"]
+      @app.call(env.merge('rack.recursive.include' => method(:include)))
+    rescue ForwardRequest => req
+      call(env.merge(req.env))
+    end
+
+    def include(env, path)
+      unless path.index(@script_name) == 0 && (path[@script_name.size] == ?/ ||
+                                               path[@script_name.size].nil?)
+        raise ArgumentError, "can only include below #{@script_name}, not #{path}"
+      end
+
+      env = env.merge("PATH_INFO" => path, "SCRIPT_NAME" => @script_name,
+                      "REQUEST_METHOD" => "GET",
+                      "CONTENT_LENGTH" => "0", "CONTENT_TYPE" => "",
+                      "rack.input" => StringIO.new(""))
+      @app.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/reloader.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/reloader.rb
new file mode 100644
index 0000000000..aa2f060be5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/reloader.rb
@@ -0,0 +1,106 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'pathname'
+
+module Rack
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # What makes it especially suited for use in a production environment is that
+  # any file will only be checked once and there will only be made one system
+  # call stat(2).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called.
+  #
+  # It is performing a check/reload cycle at the start of every request, but
+  # also respects a cool down time, during which nothing will be done.
+  class Reloader
+    def initialize(app, cooldown = 10, backend = Stat)
+      @app = app
+      @cooldown = cooldown
+      @last = (Time.now - cooldown)
+      @cache = {}
+      @mtimes = {}
+
+      extend backend
+    end
+
+    def call(env)
+      if @cooldown and Time.now > @last + @cooldown
+        if Thread.list.size > 1
+          Thread.exclusive{ reload! }
+        else
+          reload!
+        end
+
+        @last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    def reload!(stderr = $stderr)
+      rotation do |file, mtime|
+        previous_mtime = @mtimes[file] ||= mtime
+        safe_load(file, mtime, stderr) if mtime > previous_mtime
+      end
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file, mtime, stderr = $stderr)
+      load(file)
+      stderr.puts "#{self.class}: reloaded `#{file}'"
+      file
+    rescue LoadError, SyntaxError => ex
+      stderr.puts ex
+    ensure
+      @mtimes[file] = mtime
+    end
+
+    module Stat
+      def rotation
+        files = [$0, *$LOADED_FEATURES].uniq
+        paths = ['./', *$LOAD_PATH].uniq
+
+        files.map{|file|
+          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
+
+          found, stat = figure_path(file, paths)
+          next unless found and stat and mtime = stat.mtime
+
+          @cache[file] = found
+
+          yield(found, mtime)
+        }.compact
+      end
+
+      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
+      # the +file+ might reside in. Returns the full path and File::Stat for the
+      # path.
+      def figure_path(file, paths)
+        found = @cache[file]
+        found = file if !found and Pathname.new(file).absolute?
+        found, stat = safe_stat(found)
+        return found, stat if found
+
+        paths.each do |possible_path|
+          path = ::File.join(possible_path, file)
+          found, stat = safe_stat(path)
+          return ::File.expand_path(found), stat if found
+        end
+      end
+
+      def safe_stat(file)
+        return unless file
+        stat = ::File.stat(file)
+        return file, stat if stat.file?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        @cache.delete(file) and false
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/request.rb
new file mode 100644
index 0000000000..0bff7af038
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/request.rb
@@ -0,0 +1,254 @@
+require 'rack/utils'
+
+module Rack
+  # Rack::Request provides a convenient interface to a Rack
+  # environment.  It is stateless, the environment +env+ passed to the
+  # constructor will be directly modified.
+  #
+  #   req = Rack::Request.new(env)
+  #   req.post?
+  #   req.params["data"]
+  #
+  # The environment hash passed will store a reference to the Request object
+  # instantiated so that it will only instantiate if an instance of the Request
+  # object doesn't already exist.
+
+  class Request
+    # The environment of the request.
+    attr_reader :env
+
+    def self.new(env, *args)
+      if self == Rack::Request
+        env["rack.request"] ||= super
+      else
+        super
+      end
+    end
+
+    def initialize(env)
+      @env = env
+    end
+
+    def body;            @env["rack.input"]                       end
+    def scheme;          @env["rack.url_scheme"]                  end
+    def script_name;     @env["SCRIPT_NAME"].to_s                 end
+    def path_info;       @env["PATH_INFO"].to_s                   end
+    def port;            @env["SERVER_PORT"].to_i                 end
+    def request_method;  @env["REQUEST_METHOD"]                   end
+    def query_string;    @env["QUERY_STRING"].to_s                end
+    def content_length;  @env['CONTENT_LENGTH']                   end
+    def content_type;    @env['CONTENT_TYPE']                     end
+    def session;         @env['rack.session'] ||= {}              end
+    def session_options; @env['rack.session.options'] ||= {}      end
+
+    # The media type (type/subtype) portion of the CONTENT_TYPE header
+    # without any media type parameters. e.g., when CONTENT_TYPE is
+    # "text/plain;charset=utf-8", the media-type is "text/plain".
+    #
+    # For more information on the use of media types in HTTP, see:
+    # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
+    def media_type
+      content_type && content_type.split(/\s*[;,]\s*/, 2).first.downcase
+    end
+
+    # The media type parameters provided in CONTENT_TYPE as a Hash, or
+    # an empty Hash if no CONTENT_TYPE or media-type parameters were
+    # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
+    # this method responds with the following Hash:
+    #   { 'charset' => 'utf-8' }
+    def media_type_params
+      return {} if content_type.nil?
+      content_type.split(/\s*[;,]\s*/)[1..-1].
+        collect { |s| s.split('=', 2) }.
+        inject({}) { |hash,(k,v)| hash[k.downcase] = v ; hash }
+    end
+
+    # The character set of the request body if a "charset" media type
+    # parameter was given, or nil if no "charset" was specified. Note
+    # that, per RFC2616, text/* media types that specify no explicit
+    # charset are to be considered ISO-8859-1.
+    def content_charset
+      media_type_params['charset']
+    end
+
+    def host
+      # Remove port number.
+      (@env["HTTP_HOST"] || @env["SERVER_NAME"]).gsub(/:\d+\z/, '')
+    end
+
+    def script_name=(s); @env["SCRIPT_NAME"] = s.to_s             end
+    def path_info=(s);   @env["PATH_INFO"] = s.to_s               end
+
+    def get?;            request_method == "GET"                  end
+    def post?;           request_method == "POST"                 end
+    def put?;            request_method == "PUT"                  end
+    def delete?;         request_method == "DELETE"               end
+    def head?;           request_method == "HEAD"                 end
+
+    # The set of form-data media-types. Requests that do not indicate
+    # one of the media types presents in this list will not be eligible
+    # for form-data / param parsing.
+    FORM_DATA_MEDIA_TYPES = [
+      nil,
+      'application/x-www-form-urlencoded',
+      'multipart/form-data'
+    ]
+
+    # The set of media-types. Requests that do not indicate
+    # one of the media types presents in this list will not be eligible
+    # for param parsing like soap attachments or generic multiparts
+    PARSEABLE_DATA_MEDIA_TYPES = [
+      'multipart/related',
+      'multipart/mixed'
+    ]  
+
+    # Determine whether the request body contains form-data by checking
+    # the request media_type against registered form-data media-types:
+    # "application/x-www-form-urlencoded" and "multipart/form-data". The
+    # list of form-data media types can be modified through the
+    # +FORM_DATA_MEDIA_TYPES+ array.
+    def form_data?
+      FORM_DATA_MEDIA_TYPES.include?(media_type)
+    end
+
+    # Determine whether the request body contains data by checking
+    # the request media_type against registered parse-data media-types
+    def parseable_data?
+      PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
+    end
+
+    # Returns the data recieved in the query string.
+    def GET
+      if @env["rack.request.query_string"] == query_string
+        @env["rack.request.query_hash"]
+      else
+        @env["rack.request.query_string"] = query_string
+        @env["rack.request.query_hash"]   =
+          Utils.parse_nested_query(query_string)
+      end
+    end
+
+    # Returns the data recieved in the request body.
+    #
+    # This method support both application/x-www-form-urlencoded and
+    # multipart/form-data.
+    def POST
+      if @env["rack.request.form_input"].eql? @env["rack.input"]
+        @env["rack.request.form_hash"]
+      elsif form_data? || parseable_data?
+        @env["rack.request.form_input"] = @env["rack.input"]
+        unless @env["rack.request.form_hash"] =
+            Utils::Multipart.parse_multipart(env)
+          form_vars = @env["rack.input"].read
+
+          # Fix for Safari Ajax postings that always append \0
+          form_vars.sub!(/\0\z/, '')
+
+          @env["rack.request.form_vars"] = form_vars
+          @env["rack.request.form_hash"] = Utils.parse_nested_query(form_vars)
+
+          @env["rack.input"].rewind
+        end
+        @env["rack.request.form_hash"]
+      else
+        {}
+      end
+    end
+
+    # The union of GET and POST data.
+    def params
+      self.put? ? self.GET : self.GET.update(self.POST)
+    rescue EOFError => e
+      self.GET
+    end
+
+    # shortcut for request.params[key]
+    def [](key)
+      params[key.to_s]
+    end
+
+    # shortcut for request.params[key] = value
+    def []=(key, value)
+      params[key.to_s] = value
+    end
+
+    # like Hash#values_at
+    def values_at(*keys)
+      keys.map{|key| params[key] }
+    end
+
+    # the referer of the client or '/'
+    def referer
+      @env['HTTP_REFERER'] || '/'
+    end
+    alias referrer referer
+
+
+    def cookies
+      return {}  unless @env["HTTP_COOKIE"]
+
+      if @env["rack.request.cookie_string"] == @env["HTTP_COOKIE"]
+        @env["rack.request.cookie_hash"]
+      else
+        @env["rack.request.cookie_string"] = @env["HTTP_COOKIE"]
+        # According to RFC 2109:
+        #   If multiple cookies satisfy the criteria above, they are ordered in
+        #   the Cookie header such that those with more specific Path attributes
+        #   precede those with less specific.  Ordering with respect to other
+        #   attributes (e.g., Domain) is unspecified.
+        @env["rack.request.cookie_hash"] =
+          Utils.parse_query(@env["rack.request.cookie_string"], ';,').inject({}) {|h,(k,v)|
+            h[k] = Array === v ? v.first : v
+            h
+          }
+      end
+    end
+
+    def xhr?
+      @env["HTTP_X_REQUESTED_WITH"] == "XMLHttpRequest"
+    end
+
+    # Tries to return a remake of the original request URL as a string.
+    def url
+      url = scheme + "://"
+      url << host
+
+      if scheme == "https" && port != 443 ||
+          scheme == "http" && port != 80
+        url << ":#{port}"
+      end
+
+      url << fullpath
+
+      url
+    end
+    
+    def path
+      script_name + path_info
+    end
+    
+    def fullpath
+      query_string.empty? ? path : "#{path}?#{query_string}"
+    end
+
+    def accept_encoding
+      @env["HTTP_ACCEPT_ENCODING"].to_s.split(/,\s*/).map do |part|
+        m = /^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$/.match(part) # From WEBrick
+
+        if m
+          [m[1], (m[2] || 1.0).to_f]
+        else
+          raise "Invalid value for Accept-Encoding: #{part.inspect}"
+        end
+      end
+    end
+
+    def ip
+      if addr = @env['HTTP_X_FORWARDED_FOR']
+        addr.split(',').last.strip
+      else
+        @env['REMOTE_ADDR']
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/response.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/response.rb
new file mode 100644
index 0000000000..28b4d8302f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/response.rb
@@ -0,0 +1,183 @@
+require 'rack/request'
+require 'rack/utils'
+
+module Rack
+  # Rack::Response provides a convenient interface to create a Rack
+  # response.
+  #
+  # It allows setting of headers and cookies, and provides useful
+  # defaults (a OK response containing HTML).
+  #
+  # You can use Response#write to iteratively generate your response,
+  # but note that this is buffered by Rack::Response until you call
+  # +finish+.  +finish+ however can take a block inside which calls to
+  # +write+ are syncronous with the Rack response.
+  #
+  # Your application's +call+ should end returning Response#finish.
+
+  class Response
+    attr_accessor :length
+
+    def initialize(body=[], status=200, header={}, &block)
+      @status = status
+      @header = Utils::HeaderHash.new({"Content-Type" => "text/html"}.
+                                      merge(header))
+
+      @writer = lambda { |x| @body << x }
+      @block = nil
+      @length = 0
+
+      @body = []
+
+      if body.respond_to? :to_str
+        write body.to_str
+      elsif body.respond_to?(:each)
+        body.each { |part|
+          write part.to_s
+        }
+      else
+        raise TypeError, "stringable or iterable required"
+      end
+
+      yield self  if block_given?
+    end
+
+    attr_reader :header
+    attr_accessor :status, :body
+
+    def [](key)
+      header[key]
+    end
+
+    def []=(key, value)
+      header[key] = value
+    end
+
+    def set_cookie(key, value)
+      case value
+      when Hash
+        domain  = "; domain="  + value[:domain]    if value[:domain]
+        path    = "; path="    + value[:path]      if value[:path]
+        # According to RFC 2109, we need dashes here.
+        # N.B.: cgi.rb uses spaces...
+        expires = "; expires=" + value[:expires].clone.gmtime.
+          strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
+        secure = "; secure"  if value[:secure]
+        httponly = "; HttpOnly" if value[:httponly]
+        value = value[:value]
+      end
+      value = [value]  unless Array === value
+      cookie = Utils.escape(key) + "=" +
+        value.map { |v| Utils.escape v }.join("&") +
+        "#{domain}#{path}#{expires}#{secure}#{httponly}"
+
+      case self["Set-Cookie"]
+      when Array
+        self["Set-Cookie"] << cookie
+      when String
+        self["Set-Cookie"] = [self["Set-Cookie"], cookie]
+      when nil
+        self["Set-Cookie"] = cookie
+      end
+    end
+
+    def delete_cookie(key, value={})
+      unless Array === self["Set-Cookie"]
+        self["Set-Cookie"] = [self["Set-Cookie"]].compact
+      end
+
+      self["Set-Cookie"].reject! { |cookie|
+        cookie =~ /\A#{Utils.escape(key)}=/
+      }
+
+      set_cookie(key,
+                 {:value => '', :path => nil, :domain => nil,
+                   :expires => Time.at(0) }.merge(value))
+    end
+
+    def redirect(target, status=302)
+      self.status = status
+      self["Location"] = target
+    end
+
+    def finish(&block)
+      @block = block
+
+      if [204, 304].include?(status.to_i)
+        header.delete "Content-Type"
+        [status.to_i, header.to_hash, []]
+      else
+        [status.to_i, header.to_hash, self]
+      end
+    end
+    alias to_a finish           # For *response
+
+    def each(&callback)
+      @body.each(&callback)
+      @writer = callback
+      @block.call(self)  if @block
+    end
+
+    # Append to body and update Content-Length.
+    #
+    # NOTE: Do not mix #write and direct #body access!
+    #
+    def write(str)
+      s = str.to_s
+      @length += Rack::Utils.bytesize(s)
+      @writer.call s
+
+      header["Content-Length"] = @length.to_s
+      str
+    end
+
+    def close
+      body.close if body.respond_to?(:close)
+    end
+
+    def empty?
+      @block == nil && @body.empty?
+    end
+
+    alias headers header
+
+    module Helpers
+      def invalid?;       @status < 100 || @status >= 600;       end
+
+      def informational?; @status >= 100 && @status < 200;       end
+      def successful?;    @status >= 200 && @status < 300;       end
+      def redirection?;   @status >= 300 && @status < 400;       end
+      def client_error?;  @status >= 400 && @status < 500;       end
+      def server_error?;  @status >= 500 && @status < 600;       end
+
+      def ok?;            @status == 200;                        end
+      def forbidden?;     @status == 403;                        end
+      def not_found?;     @status == 404;                        end
+
+      def redirect?;      [301, 302, 303, 307].include? @status; end
+      def empty?;         [201, 204, 304].include?      @status; end
+
+      # Headers
+      attr_reader :headers, :original_headers
+
+      def include?(header)
+        !!headers[header]
+      end
+
+      def content_type
+        headers["Content-Type"]
+      end
+
+      def content_length
+        cl = headers["Content-Length"]
+        cl ? cl.to_i : cl
+      end
+
+      def location
+        headers["Location"]
+      end
+    end
+
+    include Helpers
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/rewindable_input.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/rewindable_input.rb
new file mode 100644
index 0000000000..9e9b21ff99
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/rewindable_input.rb
@@ -0,0 +1,98 @@
+require 'tempfile'
+
+module Rack
+  # Class which can make any IO object rewindable, including non-rewindable ones. It does
+  # this by buffering the data into a tempfile, which is rewindable.
+  #
+  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
+  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
+  # to easily make it rewindable.
+  #
+  # Don't forget to call #close when you're done. This frees up temporary resources that
+  # RewindableInput uses, though it does *not* close the original IO object.
+  class RewindableInput
+    def initialize(io)
+      @io = io
+      @rewindable_io = nil
+      @unlinked = false
+    end
+    
+    def gets
+      make_rewindable unless @rewindable_io
+      @rewindable_io.gets
+    end
+    
+    def read(*args)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.read(*args)
+    end
+    
+    def each(&block)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.each(&block)
+    end
+    
+    def rewind
+      make_rewindable unless @rewindable_io
+      @rewindable_io.rewind
+    end
+    
+    # Closes this RewindableInput object without closing the originally
+    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
+    # has created.
+    #
+    # This method may be called multiple times. It does nothing on subsequent calls.
+    def close
+      if @rewindable_io
+        if @unlinked
+          @rewindable_io.close
+        else
+          @rewindable_io.close!
+        end
+        @rewindable_io = nil
+      end
+    end
+    
+    private
+    
+    # Ruby's Tempfile class has a bug. Subclass it and fix it.
+    class Tempfile < ::Tempfile
+      def _close
+        @tmpfile.close if @tmpfile
+        @data[1] = nil if @data
+        @tmpfile = nil
+      end
+    end
+
+    def make_rewindable
+      # Buffer all data into a tempfile. Since this tempfile is private to this
+      # RewindableInput object, we chmod it so that nobody else can read or write
+      # it. On POSIX filesystems we also unlink the file so that it doesn't
+      # even have a file entry on the filesystem anymore, though we can still
+      # access it because we have the file handle open.
+      @rewindable_io = Tempfile.new('RackRewindableInput')
+      @rewindable_io.chmod(0000)
+      if filesystem_has_posix_semantics?
+        @rewindable_io.unlink
+        @unlinked = true
+      end
+      
+      buffer = ""
+      while @io.read(1024 * 4, buffer)
+        entire_buffer_written_out = false
+        while !entire_buffer_written_out
+          written = @rewindable_io.write(buffer)
+          entire_buffer_written_out = written == buffer.size
+          if !entire_buffer_written_out
+            buffer.slice!(0 .. written - 1)
+          end
+        end
+      end
+      @rewindable_io.rewind
+    end
+    
+    def filesystem_has_posix_semantics?
+      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/abstract/id.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/abstract/id.rb
new file mode 100644
index 0000000000..218144c17f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/abstract/id.rb
@@ -0,0 +1,142 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+# bugrep: Andreas Zehnder
+
+require 'time'
+require 'rack/request'
+require 'rack/response'
+
+module Rack
+
+  module Session
+
+    module Abstract
+
+      # ID sets up a basic framework for implementing an id based sessioning
+      # service. Cookies sent to the client for maintaining sessions will only
+      # contain an id reference. Only #get_session and #set_session are
+      # required to be overwritten.
+      #
+      # All parameters are optional.
+      # * :key determines the name of the cookie, by default it is
+      #   'rack.session'
+      # * :path, :domain, :expire_after, :secure, and :httponly set the related
+      #   cookie options as by Rack::Response#add_cookie
+      # * :defer will not set a cookie in the response.
+      # * :renew (implementation dependent) will prompt the generation of a new
+      #   session id, and migration of data to be referenced at the new id. If
+      #   :defer is set, it will be overridden and the cookie will be set.
+      # * :sidbits sets the number of bits in length that a generated session
+      #   id will be.
+      #
+      # These options can be set on a per request basis, at the location of
+      # env['rack.session.options']. Additionally the id of the session can be
+      # found within the options hash at the key :id. It is highly not
+      # recommended to change its value.
+      #
+      # Is Rack::Utils::Context compatible.
+
+      class ID
+        DEFAULT_OPTIONS = {
+          :path =>          '/',
+          :domain =>        nil,
+          :expire_after =>  nil,
+          :secure =>        false,
+          :httponly =>      true,
+          :defer =>         false,
+          :renew =>         false,
+          :sidbits =>       128
+        }
+
+        attr_reader :key, :default_options
+        def initialize(app, options={})
+          @app = app
+          @key = options[:key] || "rack.session"
+          @default_options = self.class::DEFAULT_OPTIONS.merge(options)
+        end
+
+        def call(env)
+          context(env)
+        end
+
+        def context(env, app=@app)
+          load_session(env)
+          status, headers, body = app.call(env)
+          commit_session(env, status, headers, body)
+        end
+
+        private
+
+        # Generate a new session id using Ruby #rand.  The size of the
+        # session id is controlled by the :sidbits option.
+        # Monkey patch this to use custom methods for session id generation.
+
+        def generate_sid
+          "%0#{@default_options[:sidbits] / 4}x" %
+            rand(2**@default_options[:sidbits] - 1)
+        end
+
+        # Extracts the session id from provided cookies and passes it and the
+        # environment to #get_session. It then sets the resulting session into
+        # 'rack.session', and places options and session metadata into
+        # 'rack.session.options'.
+
+        def load_session(env)
+          request = Rack::Request.new(env)
+          session_id = request.cookies[@key]
+
+          begin
+            session_id, session = get_session(env, session_id)
+            env['rack.session'] = session
+          rescue
+            env['rack.session'] = Hash.new
+          end
+
+          env['rack.session.options'] = @default_options.
+            merge(:id => session_id)
+        end
+
+        # Acquires the session from the environment and the session id from
+        # the session options and passes them to #set_session. If successful
+        # and the :defer option is not true, a cookie will be added to the
+        # response with the session's id.
+
+        def commit_session(env, status, headers, body)
+          session = env['rack.session']
+          options = env['rack.session.options']
+          session_id = options[:id]
+
+          if not session_id = set_session(env, session_id, session, options)
+            env["rack.errors"].puts("Warning! #{self.class.name} failed to save session. Content dropped.")
+            [status, headers, body]
+          elsif options[:defer] and not options[:renew]
+            env["rack.errors"].puts("Defering cookie for #{session_id}") if $VERBOSE
+            [status, headers, body]
+          else
+            cookie = Hash.new
+            cookie[:value] = session_id
+            cookie[:expires] = Time.now + options[:expire_after] unless options[:expire_after].nil?
+            response = Rack::Response.new(body, status, headers)
+            response.set_cookie(@key, cookie.merge(options))
+            response.to_a
+          end
+        end
+
+        # All thread safety and session retrival proceedures should occur here.
+        # Should return [session_id, session].
+        # If nil is provided as the session id, generation of a new valid id
+        # should occur within.
+
+        def get_session(env, sid)
+          raise '#get_session not implemented.'
+        end
+
+        # All thread safety and session storage proceedures should occur here.
+        # Should return true or false dependant on whether or not the session
+        # was saved or not.
+        def set_session(env, sid, session, options)
+          raise '#set_session not implemented.'
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/cookie.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/cookie.rb
new file mode 100644
index 0000000000..eace9bd0c6
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/cookie.rb
@@ -0,0 +1,91 @@
+require 'openssl'
+require 'rack/request'
+require 'rack/response'
+
+module Rack
+
+  module Session
+
+    # Rack::Session::Cookie provides simple cookie based session management.
+    # The session is a Ruby Hash stored as base64 encoded marshalled data
+    # set to :key (default: rack.session).
+    # When the secret key is set, cookie data is checked for data integrity.
+    #
+    # Example:
+    #
+    #     use Rack::Session::Cookie, :key => 'rack.session',
+    #                                :domain => 'foo.com',
+    #                                :path => '/',
+    #                                :expire_after => 2592000,
+    #                                :secret => 'change_me'
+    #
+    #     All parameters are optional.
+
+    class Cookie
+
+      def initialize(app, options={})
+        @app = app
+        @key = options[:key] || "rack.session"
+        @secret = options[:secret]
+        @default_options = {:domain => nil,
+          :path => "/",
+          :expire_after => nil}.merge(options)
+      end
+
+      def call(env)
+        load_session(env)
+        status, headers, body = @app.call(env)
+        commit_session(env, status, headers, body)
+      end
+
+      private
+
+      def load_session(env)
+        request = Rack::Request.new(env)
+        session_data = request.cookies[@key]
+
+        if @secret && session_data
+          session_data, digest = session_data.split("--")
+          session_data = nil  unless digest == generate_hmac(session_data)
+        end
+
+        begin
+          session_data = session_data.unpack("m*").first
+          session_data = Marshal.load(session_data)
+          env["rack.session"] = session_data
+        rescue
+          env["rack.session"] = Hash.new
+        end
+
+        env["rack.session.options"] = @default_options.dup
+      end
+
+      def commit_session(env, status, headers, body)
+        session_data = Marshal.dump(env["rack.session"])
+        session_data = [session_data].pack("m*")
+
+        if @secret
+          session_data = "#{session_data}--#{generate_hmac(session_data)}"
+        end
+
+        if session_data.size > (4096 - @key.size)
+          env["rack.errors"].puts("Warning! Rack::Session::Cookie data size exceeds 4K. Content dropped.")
+          [status, headers, body]
+        else
+          options = env["rack.session.options"]
+          cookie = Hash.new
+          cookie[:value] = session_data
+          cookie[:expires] = Time.now + options[:expire_after] unless options[:expire_after].nil?
+          response = Rack::Response.new(body, status, headers)
+          response.set_cookie(@key, cookie.merge(options))
+          response.to_a
+        end
+      end
+
+      def generate_hmac(data)
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, @secret, data)
+      end
+
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/memcache.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/memcache.rb
new file mode 100644
index 0000000000..4a65cbf35d
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/memcache.rb
@@ -0,0 +1,109 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+
+require 'rack/session/abstract/id'
+require 'memcache'
+
+module Rack
+  module Session
+    # Rack::Session::Memcache provides simple cookie based session management.
+    # Session data is stored in memcached. The corresponding session key is
+    # maintained in the cookie.
+    # You may treat Session::Memcache as you would Session::Pool with the
+    # following caveats.
+    #
+    # * Setting :expire_after to 0 would note to the Memcache server to hang
+    #   onto the session data until it would drop it according to it's own
+    #   specifications. However, the cookie sent to the client would expire
+    #   immediately.
+    #
+    # Note that memcache does drop data before it may be listed to expire. For
+    # a full description of behaviour, please see memcache's documentation.
+
+    class Memcache < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge \
+        :namespace => 'rack:session',
+        :memcache_server => 'localhost:11211'
+
+      def initialize(app, options={})
+        super
+
+        @mutex = Mutex.new
+        @pool = MemCache.
+          new @default_options[:memcache_server], @default_options
+        raise 'No memcache servers' unless @pool.servers.any?{|s|s.alive?}
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.get(sid, true)
+        end
+      end
+
+      def get_session(env, sid)
+        session = @pool.get(sid) if sid
+        @mutex.lock if env['rack.multithread']
+        unless sid and session
+          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+          session = {}
+          sid = generate_sid
+          ret = @pool.add sid, session
+          raise "Session collision on '#{sid.inspect}'" unless /^STORED/ =~ ret
+        end
+        session.instance_variable_set('@old', {}.merge(session))
+        return [sid, session]
+      rescue MemCache::MemCacheError, Errno::ECONNREFUSED # MemCache server cannot be contacted
+        warn "#{self} is unable to find server."
+        warn $!.inspect
+        return [ nil, {} ]
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def set_session(env, session_id, new_session, options)
+        expiry = options[:expire_after]
+        expiry = expiry.nil? ? 0 : expiry + 1
+
+        @mutex.lock if env['rack.multithread']
+        session = @pool.get(session_id) || {}
+        if options[:renew] or options[:drop]
+          @pool.delete session_id
+          return false if options[:drop]
+          session_id = generate_sid
+          @pool.add session_id, 0 # so we don't worry about cache miss on #set
+        end
+        old_session = new_session.instance_variable_get('@old') || {}
+        session = merge_sessions session_id, old_session, new_session, session
+        @pool.set session_id, session, expiry
+        return session_id
+      rescue MemCache::MemCacheError, Errno::ECONNREFUSED # MemCache server cannot be contacted
+        warn "#{self} is unable to find server."
+        warn $!.inspect
+        return false
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      private
+
+      def merge_sessions sid, old, new, cur=nil
+        cur ||= {}
+        unless Hash === old and Hash === new
+          warn 'Bad old or new sessions provided.'
+          return cur
+        end
+
+        delete = old.keys - new.keys
+        warn "//@#{sid}: delete #{delete*','}" if $VERBOSE and not delete.empty?
+        delete.each{|k| cur.delete k }
+
+        update = new.keys.select{|k| new[k] != old[k] }
+        warn "//@#{sid}: update #{update*','}" if $VERBOSE and not update.empty?
+        update.each{|k| cur[k] = new[k] }
+
+        cur
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/pool.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/pool.rb
new file mode 100644
index 0000000000..f6f87408bb
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/pool.rb
@@ -0,0 +1,100 @@
+# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
+# THANKS:
+#   apeiros, for session id generation, expiry setup, and threadiness
+#   sergio, threadiness and bugreps
+
+require 'rack/session/abstract/id'
+require 'thread'
+
+module Rack
+  module Session
+    # Rack::Session::Pool provides simple cookie based session management.
+    # Session data is stored in a hash held by @pool.
+    # In the context of a multithreaded environment, sessions being
+    # committed to the pool is done in a merging manner.
+    #
+    # The :drop option is available in rack.session.options if you with to
+    # explicitly remove the session from the session cache.
+    #
+    # Example:
+    #   myapp = MyRackApp.new
+    #   sessioned = Rack::Session::Pool.new(myapp,
+    #     :domain => 'foo.com',
+    #     :expire_after => 2592000
+    #   )
+    #   Rack::Handler::WEBrick.run sessioned
+
+    class Pool < Abstract::ID
+      attr_reader :mutex, :pool
+      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.merge :drop => false
+
+      def initialize(app, options={})
+        super
+        @pool = Hash.new
+        @mutex = Mutex.new
+      end
+
+      def generate_sid
+        loop do
+          sid = super
+          break sid unless @pool.key? sid
+        end
+      end
+
+      def get_session(env, sid)
+        session = @pool[sid] if sid
+        @mutex.lock if env['rack.multithread']
+        unless sid and session
+          env['rack.errors'].puts("Session '#{sid.inspect}' not found, initializing...") if $VERBOSE and not sid.nil?
+          session = {}
+          sid = generate_sid
+          @pool.store sid, session
+        end
+        session.instance_variable_set('@old', {}.merge(session))
+        return [sid, session]
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      def set_session(env, session_id, new_session, options)
+        @mutex.lock if env['rack.multithread']
+        session = @pool[session_id]
+        if options[:renew] or options[:drop]
+          @pool.delete session_id
+          return false if options[:drop]
+          session_id = generate_sid
+          @pool.store session_id, 0
+        end
+        old_session = new_session.instance_variable_get('@old') || {}
+        session = merge_sessions session_id, old_session, new_session, session
+        @pool.store session_id, session
+        return session_id
+      rescue
+        warn "#{new_session.inspect} has been lost."
+        warn $!.inspect
+      ensure
+        @mutex.unlock if env['rack.multithread']
+      end
+
+      private
+
+      def merge_sessions sid, old, new, cur=nil
+        cur ||= {}
+        unless Hash === old and Hash === new
+          warn 'Bad old or new sessions provided.'
+          return cur
+        end
+
+        delete = old.keys - new.keys
+        warn "//@#{sid}: dropping #{delete*','}" if $DEBUG and not delete.empty?
+        delete.each{|k| cur.delete k }
+
+        update = new.keys.select{|k| new[k] != old[k] }
+        warn "//@#{sid}: updating #{update*','}" if $DEBUG and not update.empty?
+        update.each{|k| cur[k] = new[k] }
+
+        cur
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showexceptions.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showexceptions.rb
new file mode 100644
index 0000000000..697bc41fdb
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showexceptions.rb
@@ -0,0 +1,349 @@
+require 'ostruct'
+require 'erb'
+require 'rack/request'
+require 'rack/utils'
+
+module Rack
+  # Rack::ShowExceptions catches all exceptions raised from the app it
+  # wraps.  It shows a useful backtrace with the sourcefile and
+  # clickable context, the whole Rack environment and the request
+  # data.
+  #
+  # Be careful when you use this on public-facing sites as it could
+  # reveal information helpful to attackers.
+
+  class ShowExceptions
+    CONTEXT = 7
+
+    def initialize(app)
+      @app = app
+      @template = ERB.new(TEMPLATE)
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue StandardError, LoadError, SyntaxError => e
+      backtrace = pretty(env, e)
+      [500,
+       {"Content-Type" => "text/html",
+        "Content-Length" => backtrace.join.size.to_s},
+       backtrace]
+    end
+
+    def pretty(env, exception)
+      req = Rack::Request.new(env)
+      path = (req.script_name + req.path_info).squeeze("/")
+
+      frames = exception.backtrace.map { |line|
+        frame = OpenStruct.new
+        if line =~ /(.*?):(\d+)(:in `(.*)')?/
+          frame.filename = $1
+          frame.lineno = $2.to_i
+          frame.function = $4
+
+          begin
+            lineno = frame.lineno-1
+            lines = ::File.readlines(frame.filename)
+            frame.pre_context_lineno = [lineno-CONTEXT, 0].max
+            frame.pre_context = lines[frame.pre_context_lineno...lineno]
+            frame.context_line = lines[lineno].chomp
+            frame.post_context_lineno = [lineno+CONTEXT, lines.size].min
+            frame.post_context = lines[lineno+1..frame.post_context_lineno]
+          rescue
+          end
+
+          frame
+        else
+          nil
+        end
+      }.compact
+
+      env["rack.errors"].puts "#{exception.class}: #{exception.message}"
+      env["rack.errors"].puts exception.backtrace.map { |l| "\t" + l }
+      env["rack.errors"].flush
+
+      [@template.result(binding)]
+    end
+
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Utils.escape_html(obj)
+      else
+        Utils.escape_html(obj.inspect)
+      end
+    end
+
+    # :stopdoc:
+
+# adapted from Django <djangoproject.com>
+# Copyright (c) 2005, the Lawrence Journal-World
+# Used under the modified BSD license:
+# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+TEMPLATE = <<'HTML'
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <meta name="robots" content="NONE,NOARCHIVE" />
+  <title><%=h exception.class %> at <%=h path %></title>
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; }
+    h2 { margin-bottom:.8em; }
+    h2 span { font-size:80%; color:#666; font-weight:normal; }
+    h3 { margin:1em 0 .5em 0; }
+    h4 { margin:0 0 .5em 0; font-weight: normal; }
+    table {
+        border:1px solid #ccc; border-collapse: collapse; background:white; }
+    tbody td, tbody th { vertical-align:top; padding:2px 3px; }
+    thead th {
+        padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
+        font-weight:normal; font-size:11px; border:1px solid #ddd; }
+    tbody th { text-align:right; color:#666; padding-right:.5em; }
+    table.vars { margin:5px 0 2px 40px; }
+    table.vars td, table.req td { font-family:monospace; }
+    table td.code { width:100%;}
+    table td.code div { overflow:hidden; }
+    table.source th { color:#666; }
+    table.source td {
+        font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
+    ul.traceback { list-style-type:none; }
+    ul.traceback li.frame { margin-bottom:1em; }
+    div.context { margin: 10px 0; }
+    div.context ol {
+        padding-left:30px; margin:0 10px; list-style-position: inside; }
+    div.context ol li {
+        font-family:monospace; white-space:pre; color:#666; cursor:pointer; }
+    div.context ol.context-line li { color:black; background-color:#ccc; }
+    div.context ol.context-line li span { float: right; }
+    div.commands { margin-left: 40px; }
+    div.commands a { color:black; text-decoration:none; }
+    #summary { background: #ffc; }
+    #summary h2 { font-weight: normal; color: #666; }
+    #summary ul#quicklinks { list-style-type: none; margin-bottom: 2em; }
+    #summary ul#quicklinks li { float: left; padding: 0 1em; }
+    #summary ul#quicklinks>li+li { border-left: 1px #666 solid; }
+    #explanation { background:#eee; }
+    #template, #template-not-exist { background:#f6f6f6; }
+    #template-not-exist ul { margin: 0 0 0 20px; }
+    #traceback { background:#eee; }
+    #requestinfo { background:#f6f6f6; padding-left:120px; }
+    #summary table { border:none; background:transparent; }
+    #requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }
+    #requestinfo h3 { margin-bottom:-1em; }
+    .error { background: #ffc; }
+    .specific { color:#cc3300; font-weight:bold; }
+  </style>
+  <script type="text/javascript">
+  //<!--
+    function getElementsByClassName(oElm, strTagName, strClassName){
+        // Written by Jonathan Snook, http://www.snook.ca/jon;
+        // Add-ons by Robert Nyman, http://www.robertnyman.com
+        var arrElements = (strTagName == "*" && document.all)? document.all :
+        oElm.getElementsByTagName(strTagName);
+        var arrReturnElements = new Array();
+        strClassName = strClassName.replace(/\-/g, "\\-");
+        var oRegExp = new RegExp("(^|\\s)" + strClassName + "(\\s|$$)");
+        var oElement;
+        for(var i=0; i<arrElements.length; i++){
+            oElement = arrElements[i];
+            if(oRegExp.test(oElement.className)){
+                arrReturnElements.push(oElement);
+            }
+        }
+        return (arrReturnElements)
+    }
+    function hideAll(elems) {
+      for (var e = 0; e < elems.length; e++) {
+        elems[e].style.display = 'none';
+      }
+    }
+    window.onload = function() {
+      hideAll(getElementsByClassName(document, 'table', 'vars'));
+      hideAll(getElementsByClassName(document, 'ol', 'pre-context'));
+      hideAll(getElementsByClassName(document, 'ol', 'post-context'));
+    }
+    function toggle() {
+      for (var i = 0; i < arguments.length; i++) {
+        var e = document.getElementById(arguments[i]);
+        if (e) {
+          e.style.display = e.style.display == 'none' ? 'block' : 'none';
+        }
+      }
+      return false;
+    }
+    function varToggle(link, id) {
+      toggle('v' + id);
+      var s = link.getElementsByTagName('span')[0];
+      var uarr = String.fromCharCode(0x25b6);
+      var darr = String.fromCharCode(0x25bc);
+      s.innerHTML = s.innerHTML == uarr ? darr : uarr;
+      return false;
+    }
+    //-->
+  </script>
+</head>
+<body>
+
+<div id="summary">
+  <h1><%=h exception.class %> at <%=h path %></h1>
+  <h2><%=h exception.message %></h2>
+  <table><tr>
+    <th>Ruby</th>
+    <td><code><%=h frames.first.filename %></code>: in <code><%=h frames.first.function %></code>, line <%=h frames.first.lineno %></td>
+  </tr><tr>
+    <th>Web</th>
+    <td><code><%=h req.request_method %> <%=h(req.host + path)%></code></td>
+  </tr></table>
+
+  <h3>Jump to:</h3>
+  <ul id="quicklinks">
+    <li><a href="#get-info">GET</a></li>
+    <li><a href="#post-info">POST</a></li>
+    <li><a href="#cookie-info">Cookies</a></li>
+    <li><a href="#env-info">ENV</a></li>
+  </ul>
+</div>
+
+<div id="traceback">
+  <h2>Traceback <span>(innermost first)</span></h2>
+  <ul class="traceback">
+<% frames.each { |frame| %>
+      <li class="frame">
+        <code><%=h frame.filename %></code>: in <code><%=h frame.function %></code>
+
+          <% if frame.context_line %>
+          <div class="context" id="c<%=h frame.object_id %>">
+              <% if frame.pre_context %>
+              <ol start="<%=h frame.pre_context_lineno+1 %>" class="pre-context" id="pre<%=h frame.object_id %>">
+                <% frame.pre_context.each { |line| %>
+                <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
+                <% } %>
+              </ol>
+              <% end %>
+
+            <ol start="<%=h frame.lineno %>" class="context-line">
+              <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h frame.context_line %><span>...</span></li></ol>
+
+              <% if frame.post_context %>
+              <ol start='<%=h frame.lineno+1 %>' class="post-context" id="post<%=h frame.object_id %>">
+                <% frame.post_context.each { |line| %>
+                <li onclick="toggle('pre<%=h frame.object_id %>', 'post<%=h frame.object_id %>')"><%=h line %></li>
+                <% } %>
+              </ol>
+              <% end %>
+          </div>
+          <% end %>
+      </li>
+<% } %>
+  </ul>
+</div>
+
+<div id="requestinfo">
+  <h2>Request information</h2>
+
+  <h3 id="get-info">GET</h3>
+  <% unless req.GET.empty? %>
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+          <% req.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
+          <tr>
+            <td><%=h key %></td>
+            <td class="code"><div><%=h val.inspect %></div></td>
+          </tr>
+          <% } %>
+      </tbody>
+    </table>
+  <% else %>
+    <p>No GET data.</p>
+  <% end %>
+
+  <h3 id="post-info">POST</h3>
+  <% unless req.POST.empty? %>
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+          <% req.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
+          <tr>
+            <td><%=h key %></td>
+            <td class="code"><div><%=h val.inspect %></div></td>
+          </tr>
+          <% } %>
+      </tbody>
+    </table>
+  <% else %>
+    <p>No POST data.</p>
+  <% end %>
+
+
+  <h3 id="cookie-info">COOKIES</h3>
+  <% unless req.cookies.empty? %>
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% req.cookies.each { |key, val| %>
+          <tr>
+            <td><%=h key %></td>
+            <td class="code"><div><%=h val.inspect %></div></td>
+          </tr>
+        <% } %>
+      </tbody>
+    </table>
+  <% else %>
+    <p>No cookie data.</p>
+  <% end %>
+
+  <h3 id="env-info">Rack ENV</h3>
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+          <% env.sort_by { |k, v| k.to_s }.each { |key, val| %>
+          <tr>
+            <td><%=h key %></td>
+            <td class="code"><div><%=h val %></div></td>
+          </tr>
+          <% } %>
+      </tbody>
+    </table>
+
+</div>
+
+<div id="explanation">
+  <p>
+    You're seeing this error because you use <code>Rack::ShowExceptions</code>.
+  </p>
+</div>
+
+</body>
+</html>
+HTML
+
+    # :startdoc:
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showstatus.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showstatus.rb
new file mode 100644
index 0000000000..28258c7c89
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showstatus.rb
@@ -0,0 +1,106 @@
+require 'erb'
+require 'rack/request'
+require 'rack/utils'
+
+module Rack
+  # Rack::ShowStatus catches all empty responses the app it wraps and
+  # replaces them with a site explaining the error.
+  #
+  # Additional details can be put into <tt>rack.showstatus.detail</tt>
+  # and will be shown as HTML.  If such details exist, the error page
+  # is always rendered, even if the reply was not empty.
+
+  class ShowStatus
+    def initialize(app)
+      @app = app
+      @template = ERB.new(TEMPLATE)
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+      empty = headers['Content-Length'].to_i <= 0
+
+      # client or server error, or explicit message
+      if (status.to_i >= 400 && empty) || env["rack.showstatus.detail"]
+        req = Rack::Request.new(env)
+        message = Rack::Utils::HTTP_STATUS_CODES[status.to_i] || status.to_s
+        detail = env["rack.showstatus.detail"] || message
+        body = @template.result(binding)
+        size = Rack::Utils.bytesize(body)
+        [status, headers.merge("Content-Type" => "text/html", "Content-Length" => size.to_s), [body]]
+      else
+        [status, headers, body]
+      end
+    end
+
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Utils.escape_html(obj)
+      else
+        Utils.escape_html(obj.inspect)
+      end
+    end
+
+    # :stopdoc:
+
+# adapted from Django <djangoproject.com>
+# Copyright (c) 2005, the Lawrence Journal-World
+# Used under the modified BSD license:
+# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+TEMPLATE = <<'HTML'
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <title><%=h message %> at <%=h req.script_name + req.path_info %></title>
+  <meta name="robots" content="NONE,NOARCHIVE" />
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; background:#eee; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; margin-bottom:.4em; }
+    h1 span { font-size:60%; color:#666; font-weight:normal; }
+    table { border:none; border-collapse: collapse; width:100%; }
+    td, th { vertical-align:top; padding:2px 3px; }
+    th { width:12em; text-align:right; color:#666; padding-right:.5em; }
+    #info { background:#f6f6f6; }
+    #info ol { margin: 0.5em 4em; }
+    #info ol li { font-family: monospace; }
+    #summary { background: #ffc; }
+    #explanation { background:#eee; border-bottom: 0px none; }
+  </style>
+</head>
+<body>
+  <div id="summary">
+    <h1><%=h message %> <span>(<%= status.to_i %>)</span></h1>
+    <table class="meta">
+      <tr>
+        <th>Request Method:</th>
+        <td><%=h req.request_method %></td>
+      </tr>
+      <tr>
+        <th>Request URL:</th>
+      <td><%=h req.url %></td>
+      </tr>
+    </table>
+  </div>
+  <div id="info">
+    <p><%= detail %></p>
+  </div>
+
+  <div id="explanation">
+    <p>
+    You're seeing this error because you use <code>Rack::ShowStatus</code>.
+    </p>
+  </div>
+</body>
+</html>
+HTML
+
+    # :startdoc:
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/static.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/static.rb
new file mode 100644
index 0000000000..168e8f83b2
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/static.rb
@@ -0,0 +1,38 @@
+module Rack
+
+  # The Rack::Static middleware intercepts requests for static files
+  # (javascript files, images, stylesheets, etc) based on the url prefixes
+  # passed in the options, and serves them using a Rack::File object. This
+  # allows a Rack stack to serve both static and dynamic content.
+  #
+  # Examples:
+  #     use Rack::Static, :urls => ["/media"]
+  #     will serve all requests beginning with /media from the "media" folder
+  #     located in the current directory (ie media/*).
+  #
+  #     use Rack::Static, :urls => ["/css", "/images"], :root => "public"
+  #     will serve all requests beginning with /css or /images from the folder
+  #     "public" in the current directory (ie public/css/* and public/images/*)
+
+  class Static
+
+    def initialize(app, options={})
+      @app = app
+      @urls = options[:urls] || ["/favicon.ico"]
+      root = options[:root] || Dir.pwd
+      @file_server = Rack::File.new(root)
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      can_serve = @urls.any? { |url| path.index(url) == 0 }
+
+      if can_serve
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/urlmap.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/urlmap.rb
new file mode 100644
index 0000000000..fcf6616c58
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/urlmap.rb
@@ -0,0 +1,55 @@
+module Rack
+  # Rack::URLMap takes a hash mapping urls or paths to apps, and
+  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
+  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
+  #
+  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
+  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
+  # PATH_INFO.  This should be taken care of when you need to
+  # reconstruct the URL in order to create links.
+  #
+  # URLMap dispatches in such a way that the longest paths are tried
+  # first, since they are most specific.
+
+  class URLMap
+    def initialize(map = {})
+      remap(map)
+    end
+
+    def remap(map)
+      @mapping = map.map { |location, app|
+        if location =~ %r{\Ahttps?://(.*?)(/.*)}
+          host, location = $1, $2
+        else
+          host = nil
+        end
+
+        unless location[0] == ?/
+          raise ArgumentError, "paths need to start with /"
+        end
+        location = location.chomp('/')
+
+        [host, location, app]
+      }.sort_by { |(h, l, a)| [h ? -h.size : (-1.0 / 0.0), -l.size] }  # Longest path first
+    end
+
+    def call(env)
+      path = env["PATH_INFO"].to_s.squeeze("/")
+      script_name = env['SCRIPT_NAME']
+      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
+      @mapping.each { |host, location, app|
+        next unless (hHost == host || sName == host \
+          || (host.nil? && (hHost == sName || hHost == sName+':'+sPort)))
+        next unless location == path[0, location.size]
+        next unless path[location.size] == nil || path[location.size] == ?/
+
+        return app.call(
+          env.merge(
+            'SCRIPT_NAME' => (script_name + location),
+            'PATH_INFO'   => path[location.size..-1]))
+      }
+      [404, {"Content-Type" => "text/plain"}, ["Not Found: #{path}"]]
+    end
+  end
+end
+
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/utils.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/utils.rb
new file mode 100644
index 0000000000..42e2e698f4
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/utils.rb
@@ -0,0 +1,516 @@
+# -*- encoding: binary -*-
+
+require 'set'
+require 'tempfile'
+
+module Rack
+  # Rack::Utils contains a grab-bag of useful methods for writing web
+  # applications adopted from all kinds of Ruby libraries.
+
+  module Utils
+    # Performs URI escaping so that you can construct proper
+    # query strings faster.  Use this rather than the cgi.rb
+    # version since it's faster.  (Stolen from Camping).
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2'*$1.size).join('%').upcase
+      }.tr(' ', '+')
+    end
+    module_function :escape
+
+    # Unescapes a URI escaped string. (Stolen from Camping).
+    def unescape(s)
+      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+        [$1.delete('%')].pack('H*')
+      }
+    end
+    module_function :unescape
+
+    # Stolen from Mongrel, with some small modifications:
+    # Parses a query string by breaking it up at the '&'
+    # and ';' characters.  You can also use this to parse
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to '&;').
+    def parse_query(qs, d = '&;')
+      params = {}
+
+      (qs || '').split(/[#{d}] */n).each do |p|
+        k, v = unescape(p).split('=', 2)
+
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      end
+
+      return params
+    end
+    module_function :parse_query
+
+    def parse_nested_query(qs, d = '&;')
+      params = {}
+
+      (qs || '').split(/[#{d}] */n).each do |p|
+        k, v = unescape(p).split('=', 2)
+        normalize_params(params, k, v)
+      end
+
+      return params
+    end
+    module_function :parse_nested_query
+
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        params[k] = v
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
+    end
+    module_function :normalize_params
+
+    def build_query(params)
+      params.map { |k, v|
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          escape(k) + "=" + escape(v)
+        end
+      }.join("&")
+    end
+    module_function :build_query
+
+    def build_nested_query(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          build_nested_query(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        }.join("&")
+      when String
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{escape(value)}"
+      else
+        prefix
+      end
+    end
+    module_function :build_nested_query
+
+    # Escape ampersands, brackets and quotes to their HTML/XML entities.
+    def escape_html(string)
+      string.to_s.gsub("&", "&amp;").
+        gsub("<", "&lt;").
+        gsub(">", "&gt;").
+        gsub("'", "&#39;").
+        gsub('"', "&quot;")
+    end
+    module_function :escape_html
+
+    def select_best_encoding(available_encodings, accept_encoding)
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+
+      expanded_accept_encoding =
+        accept_encoding.map { |m, q|
+          if m == "*"
+            (available_encodings - accept_encoding.map { |m2, _| m2 }).map { |m2| [m2, q] }
+          else
+            [[m, q]]
+          end
+        }.inject([]) { |mem, list|
+          mem + list
+        }
+
+      encoding_candidates = expanded_accept_encoding.sort_by { |_, q| -q }.map { |m, _| m }
+
+      unless encoding_candidates.include?("identity")
+        encoding_candidates.push("identity")
+      end
+
+      expanded_accept_encoding.find_all { |m, q|
+        q == 0.0
+      }.each { |m, _|
+        encoding_candidates.delete(m)
+      }
+
+      return (encoding_candidates & available_encodings)[0]
+    end
+    module_function :select_best_encoding
+
+    # Return the bytesize of String; uses String#length under Ruby 1.8 and
+    # String#bytesize under 1.9.
+    if ''.respond_to?(:bytesize)
+      def bytesize(string)
+        string.bytesize
+      end
+    else
+      def bytesize(string)
+        string.size
+      end
+    end
+    module_function :bytesize
+
+    # Context allows the use of a compatible middleware at different points
+    # in a request handling stack. A compatible middleware must define
+    # #context which should take the arguments env and app. The first of which
+    # would be the request environment. The second of which would be the rack
+    # application that the request would be forwarded to.
+    class Context
+      attr_reader :for, :app
+
+      def initialize(app_f, app_r)
+        raise 'running context does not respond to #context' unless app_f.respond_to? :context
+        @for, @app = app_f, app_r
+      end
+
+      def call(env)
+        @for.context(env, @app)
+      end
+
+      def recontext(app)
+        self.class.new(@for, app)
+      end
+
+      def context(env, app=@app)
+        recontext(app).call(env)
+      end
+    end
+
+    # A case-insensitive Hash that preserves the original case of a
+    # header when set.
+    class HeaderHash < Hash
+      def initialize(hash={})
+        @names = {}
+        hash.each { |k, v| self[k] = v }
+      end
+
+      def to_hash
+        inject({}) do |hash, (k,v)|
+          if v.respond_to? :to_ary
+            hash[k] = v.to_ary.join("\n")
+          else
+            hash[k] = v
+          end
+          hash
+        end
+      end
+
+      def [](k)
+        super @names[k.downcase]
+      end
+
+      def []=(k, v)
+        delete k
+        @names[k.downcase] = k
+        super k, v
+      end
+
+      def delete(k)
+        super @names.delete(k.downcase)
+      end
+
+      def include?(k)
+        @names.has_key? k.downcase
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+    end
+
+    # Every standard HTTP code mapped to the appropriate message.
+    # Stolen from Mongrel.
+    HTTP_STATUS_CODES = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      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 Large',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported'
+    }
+
+    # Responses with HTTP status codes that should not have an entity body
+    STATUS_WITH_NO_ENTITY_BODY = Set.new((100..199).to_a << 204 << 304)
+
+    # A multipart form data parser, adapted from IOWA.
+    #
+    # Usually, Rack::Request#POST takes care of calling this.
+
+    module Multipart
+      class UploadedFile
+        # The filename, *not* including the path, of the "uploaded" file
+        attr_reader :original_filename
+
+        # The content type of the "uploaded" file
+        attr_accessor :content_type
+
+        def initialize(path, content_type = "text/plain", binary = false)
+          raise "#{path} file does not exist" unless ::File.exist?(path)
+          @content_type = content_type
+          @original_filename = ::File.basename(path)
+          @tempfile = Tempfile.new(@original_filename)
+          @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+          @tempfile.binmode if binary
+          FileUtils.copy_file(path, @tempfile.path)
+        end
+
+        def path
+          @tempfile.path
+        end
+        alias_method :local_path, :path
+
+        def method_missing(method_name, *args, &block) #:nodoc:
+          @tempfile.__send__(method_name, *args, &block)
+        end
+      end
+
+      EOL = "\r\n"
+      MULTIPART_BOUNDARY = "AaB03x"
+
+      def self.parse_multipart(env)
+        unless env['CONTENT_TYPE'] =~
+            %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
+          nil
+        else
+          boundary = "--#{$1}"
+
+          params = {}
+          buf = ""
+          content_length = env['CONTENT_LENGTH'].to_i
+          input = env['rack.input']
+          input.rewind
+
+          boundary_size = Utils.bytesize(boundary) + EOL.size
+          bufsize = 16384
+
+          content_length -= boundary_size
+
+          read_buffer = ''
+
+          status = input.read(boundary_size, read_buffer)
+          raise EOFError, "bad content body"  unless status == boundary + EOL
+
+          rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/n
+
+          loop {
+            head = nil
+            body = ''
+            filename = content_type = name = nil
+
+            until head && buf =~ rx
+              if !head && i = buf.index(EOL+EOL)
+                head = buf.slice!(0, i+2) # First \r\n
+                buf.slice!(0, 2)          # Second \r\n
+
+                filename = head[/Content-Disposition:.* filename="?([^\";]*)"?/ni, 1]
+                content_type = head[/Content-Type: (.*)#{EOL}/ni, 1]
+                name = head[/Content-Disposition:.*\s+name="?([^\";]*)"?/ni, 1] || head[/Content-ID:\s*([^#{EOL}]*)/ni, 1]
+
+                if content_type || filename
+                  body = Tempfile.new("RackMultipart")
+                  body.binmode  if body.respond_to?(:binmode)
+                end
+
+                next
+              end
+
+              # Save the read body part.
+              if head && (boundary_size+4 < buf.size)
+                body << buf.slice!(0, buf.size - (boundary_size+4))
+              end
+
+              c = input.read(bufsize < content_length ? bufsize : content_length, read_buffer)
+              raise EOFError, "bad content body"  if c.nil? || c.empty?
+              buf << c
+              content_length -= c.size
+            end
+
+            # Save the rest.
+            if i = buf.index(rx)
+              body << buf.slice!(0, i)
+              buf.slice!(0, boundary_size+2)
+
+              content_length = -1  if $1 == "--"
+            end
+
+            if filename == ""
+              # filename is blank which means no file has been selected
+              data = nil
+            elsif filename
+              body.rewind
+
+              # 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.
+              filename =~ /^(?:.*[:\\\/])?(.*)/m
+              filename = $1
+
+              data = {:filename => filename, :type => content_type,
+                      :name => name, :tempfile => body, :head => head}
+            elsif !filename && content_type
+              body.rewind
+
+              # Generic multipart cases, not coming from a form
+              data = {:type => content_type,
+                      :name => name, :tempfile => body, :head => head}
+            else
+              data = body
+            end
+
+            Utils.normalize_params(params, name, data) unless data.nil?
+
+            break  if buf.empty? || content_length == -1
+          }
+
+          input.rewind
+
+          params
+        end
+      end
+
+      def self.build_multipart(params, first = true)
+        if first
+          unless params.is_a?(Hash)
+            raise ArgumentError, "value must be a Hash"
+          end
+
+          multipart = false
+          query = lambda { |value|
+            case value
+            when Array
+              value.each(&query)
+            when Hash
+              value.values.each(&query)
+            when UploadedFile
+              multipart = true
+            end
+          }
+          params.values.each(&query)
+          return nil unless multipart
+        end
+
+        flattened_params = Hash.new
+
+        params.each do |key, value|
+          k = first ? key.to_s : "[#{key}]"
+
+          case value
+          when Array
+            value.map { |v|
+              build_multipart(v, false).each { |subkey, subvalue|
+                flattened_params["#{k}[]#{subkey}"] = subvalue
+              }
+            }
+          when Hash
+            build_multipart(value, false).each { |subkey, subvalue|
+              flattened_params[k + subkey] = subvalue
+            }
+          else
+            flattened_params[k] = value
+          end
+        end
+
+        if first
+          flattened_params.map { |name, file|
+            if file.respond_to?(:original_filename)
+              ::File.open(file.path, "rb") do |f|
+                f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
+Content-Type: #{file.content_type}\r
+Content-Length: #{::File.stat(file.path).size}\r
+\r
+#{f.read}\r
+EOF
+              end
+            else
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"\r
+\r
+#{file}\r
+EOF
+            end
+          }.join + "--#{MULTIPART_BOUNDARY}--\r"
+        else
+          flattened_params
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_view.rb b/actionpack/lib/action_view.rb
index dd352f9ce0..94138097e3 100644
--- a/actionpack/lib/action_view.rb
+++ b/actionpack/lib/action_view.rb
@@ -21,16 +21,10 @@
 # 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
-require 'active_support/core/all'
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift activesupport_path if File.directory?(activesupport_path)
+require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
 
 require File.join(File.dirname(__FILE__), "action_pack")
 
diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb
index 44bd401631..56f0b5ef4f 100644
--- a/actionpack/lib/action_view/base.rb
+++ b/actionpack/lib/action_view/base.rb
@@ -1,3 +1,6 @@
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/delegation'
+
 module ActionView #:nodoc:
   class ActionViewError < StandardError #:nodoc:
   end
diff --git a/actionpack/lib/action_view/helpers/form_helper.rb b/actionpack/lib/action_view/helpers/form_helper.rb
index d03879dd76..beef661a37 100644
--- a/actionpack/lib/action_view/helpers/form_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_helper.rb
@@ -2,6 +2,7 @@ require 'cgi'
 require 'action_view/helpers/date_helper'
 require 'action_view/helpers/tag_helper'
 require 'action_view/helpers/form_tag_helper'
+require 'active_support/core_ext/class/inheritable_attributes'
 
 module ActionView
   module Helpers
@@ -246,7 +247,7 @@ module ActionView
       # <tt>labelling_form</tt>.
       #
       # The custom FormBuilder class is automatically merged with the options
-      # of a nested fields_for call, unless it's explicitly set.
+      # of a nested fields_for call, unless it's explicitely set.
       #
       # In many cases you will want to wrap the above in another helper, so you
       # could do something like the following:
@@ -620,8 +621,8 @@ module ActionView
 
       # Returns a checkbox tag tailored for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). This object must be an instance object (@object) and not a local object.
-      # It's intended that +method+ returns an integer and if that integer is above zero, then the checkbox is checked.
-      # Additional options on the input tag can be passed as a hash with +options+. The +checked_value+ defaults to 1
+      # It's intended that +method+ returns an integer and if that integer is above zero, then the checkbox is checked. 
+      # Additional options on the input tag can be passed as a hash with +options+. The +checked_value+ defaults to 1 
       # while the default +unchecked_value+ is set to 0 which is convenient for boolean values.
       #
       # ==== Gotcha
@@ -1039,8 +1040,8 @@ module ActionView
     end
   end
 
-  class Base
-    cattr_accessor :default_form_builder
-    self.default_form_builder = ::ActionView::Helpers::FormBuilder
+  class << Base
+    attr_accessor :default_form_builder
   end
+  Base.default_form_builder = ::ActionView::Helpers::FormBuilder
 end
diff --git a/actionpack/lib/action_view/helpers/form_options_helper.rb b/actionpack/lib/action_view/helpers/form_options_helper.rb
index e97aa4da49..8cb5882aab 100644
--- a/actionpack/lib/action_view/helpers/form_options_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_options_helper.rb
@@ -230,6 +230,8 @@ module ActionView
       #
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
       def options_for_select(container, selected = nil)
+        return container if String === container
+
         container = container.to_a if Hash === container
         selected, disabled = extract_selected_and_disabled(selected)
 
diff --git a/actionpack/lib/action_view/helpers/tag_helper.rb b/actionpack/lib/action_view/helpers/tag_helper.rb
index af8c4d5e21..66d7592874 100644
--- a/actionpack/lib/action_view/helpers/tag_helper.rb
+++ b/actionpack/lib/action_view/helpers/tag_helper.rb
@@ -9,7 +9,7 @@ module ActionView
       include ERB::Util
 
       BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked).to_set
-      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map(&:to_sym))
+      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attr| attr.to_sym })
 
       # Returns an empty HTML tag of type +name+ which by default is XHTML
       # compliant. Set +open+ to true to create an open tag compatible
diff --git a/actionpack/lib/action_view/paths.rb b/actionpack/lib/action_view/paths.rb
index f6d021c92a..95c56faf9c 100644
--- a/actionpack/lib/action_view/paths.rb
+++ b/actionpack/lib/action_view/paths.rb
@@ -2,7 +2,7 @@ module ActionView #:nodoc:
   class PathSet < Array #:nodoc:
     def self.type_cast(obj)
       if obj.is_a?(String)
-        cache = !Object.const_defined?(:Rails) || Rails.configuration.cache_classes
+        cache = !defined?(Rails) || !Rails.respond_to?(:configuration) || Rails.configuration.cache_classes
         Template::FileSystemPathWithFallback.new(obj, :cache => cache)
       else
         obj
diff --git a/actionpack/lib/action_view/render/partials.rb b/actionpack/lib/action_view/render/partials.rb
index 43f8a1edf8..f2429e8cef 100644
--- a/actionpack/lib/action_view/render/partials.rb
+++ b/actionpack/lib/action_view/render/partials.rb
@@ -171,11 +171,21 @@ module ActionView
   #   <% end %>
   module Partials
     extend ActiveSupport::Memoizable
+    extend ActiveSupport::DependencyModule
+    
+    included do
+      attr_accessor :_partial      
+    end
+
+    def _render_partial_from_controller(*args)
+      @assigns_added = false
+      _render_partial(*args)
+    end
 
     def _render_partial(options = {}) #:nodoc:
       options[:locals] ||= {}
 
-      case path = partial = options[:partial]        
+      case path = partial = options[:partial]
       when *_array_like_objects
         return _render_partial_collection(partial, options)
       else
@@ -222,16 +232,7 @@ module ActionView
       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 => 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}"
@@ -287,13 +288,17 @@ module ActionView
           locals = (options[:locals] ||= {})
           object ||= locals[:object] || locals[template.variable_name]
           
-          _set_locals(object, locals, template, options)          
+          _set_locals(object, locals, template, options)
+          
+          self._partial = template
+          
           _render_template(template, locals)
         end
       end
 
       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
@@ -316,6 +321,9 @@ module ActionView
           locals[template.counter_name] = index
           
           index += 1
+          
+          self._partial = template
+          
           _render_template(template, locals)
         end.join(spacer)
       end
diff --git a/actionpack/lib/action_view/render/rendering.rb b/actionpack/lib/action_view/render/rendering.rb
index 6e368f27eb..fe785e7b20 100644
--- a/actionpack/lib/action_view/render/rendering.rb
+++ b/actionpack/lib/action_view/render/rendering.rb
@@ -95,6 +95,11 @@ module ActionView
       layout ? _render_content_with_layout(text, layout, options[:locals]) : text
     end
 
+    def _render_template_from_controller(*args)
+      @assigns_added = nil
+      _render_template_with_layout(*args)
+    end
+
     def _render_template_with_layout(template, layout = nil, options = {}, partial = false)
       if controller && logger
         logger.info("Rendering #{template.identifier}" + 
diff --git a/actionpack/lib/action_view/template/handlers/erb.rb b/actionpack/lib/action_view/template/handlers/erb.rb
index a20b1b0cd3..fdcb108ffc 100644
--- a/actionpack/lib/action_view/template/handlers/erb.rb
+++ b/actionpack/lib/action_view/template/handlers/erb.rb
@@ -1,4 +1,5 @@
 require 'erb'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module ActionView
   module TemplateHandlers
diff --git a/actionpack/lib/action_view/template/text.rb b/actionpack/lib/action_view/template/text.rb
index f81174d707..a777021a12 100644
--- a/actionpack/lib/action_view/template/text.rb
+++ b/actionpack/lib/action_view/template/text.rb
@@ -1,9 +1,12 @@
 module ActionView #:nodoc:
   class TextTemplate < String #:nodoc:
+
+    def identifier() self end
     
     def render(*) self end
     
-    def exempt_from_layout?() false end
-    
+    def mime_type() Mime::HTML end
+      
+    def partial?() false end
   end
 end
diff --git a/actionpack/lib/action_view/test_case.rb b/actionpack/lib/action_view/test_case.rb
index 50bed67f7d..22adf97304 100644
--- a/actionpack/lib/action_view/test_case.rb
+++ b/actionpack/lib/action_view/test_case.rb
@@ -21,7 +21,7 @@ module ActionView
   end
 
   class TestCase < ActiveSupport::TestCase
-    include ActionController::TestCase::Assertions
+    include ActionDispatch::Assertions
     include ActionController::TestProcess
 
     class_inheritable_accessor :helper_class