Depend on rack 0.4.0 instead of vendoring it

42 files changed, 3 insertions, 4226 deletions

diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index a7a7d932c4..da5f1e81e6 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -31,6 +31,9 @@ rescue LoadError
   end
 end
 
+gem 'rack', '~> 0.4.0'
+require 'rack'
+
 module ActionController
   # TODO: Review explicit to see if they will automatically be handled by
   # the initilizer if they are really needed.
@@ -99,6 +102,5 @@ end
 autoload :Mime, 'action_controller/mime_type'
 
 autoload :HTML, 'action_controller/vendor/html-scanner'
-autoload :Rack, 'action_controller/vendor/rack'
 
 require 'action_view'
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack.rb
deleted file mode 100644
index 62a1b35880..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# Copyright (C) 2007, 2008 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.
-
-$: << File.expand_path(File.dirname(__FILE__))
-
-
-# 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 = [0,1]
-
-  # 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
-    "0.4"
-  end
-
-  autoload :Builder, "rack/builder"
-  autoload :Cascade, "rack/cascade"
-  autoload :CommonLogger, "rack/commonlogger"
-  autoload :File, "rack/file"
-  autoload :Deflater, "rack/deflater"
-  autoload :Directory, "rack/directory"
-  autoload :ForwardRequest, "rack/recursive"
-  autoload :Handler, "rack/handler"
-  autoload :Lint, "rack/lint"
-  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_controller/vendor/rack-0.4.0/rack/adapter/camping.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/adapter/camping.rb
deleted file mode 100644
index b910a13267..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/adapter/camping.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-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]
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/abstract/handler.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/abstract/handler.rb
deleted file mode 100644
index b213eac6f4..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/abstract/handler.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-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, &authenticator)
-        @app, @authenticator = app, authenticator
-      end
-
-
-      private
-
-      def unauthorized(www_authenticate = challenge)
-        return [ 401, { 'WWW-Authenticate' => www_authenticate.to_s }, [] ]
-      end
-
-      def bad_request
-        [ 400, {}, [] ]
-      end
-
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/abstract/request.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/abstract/request.rb
deleted file mode 100644
index 1d9ccec685..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/abstract/request.rb
+++ /dev/null
@@ -1,37 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/auth/basic.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/basic.rb
deleted file mode 100644
index 9557224648..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/basic.rb
+++ /dev/null
@@ -1,58 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/auth/digest/md5.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/md5.rb
deleted file mode 100644
index 6d2bd29c2e..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/md5.rb
+++ /dev/null
@@ -1,124 +0,0 @@
-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(app)
-          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_controller/vendor/rack-0.4.0/rack/auth/digest/nonce.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/nonce.rb
deleted file mode 100644
index dbe109f29a..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/nonce.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/auth/digest/params.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/params.rb
deleted file mode 100644
index 730e2efdc8..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/params.rb
+++ /dev/null
@@ -1,55 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/auth/digest/request.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/request.rb
deleted file mode 100644
index a0227543fb..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/digest/request.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-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['REQUEST_METHOD']
-        end
-
-        def digest?
-          :digest == scheme
-        end
-
-        def correct_uri?
-          @env['PATH_INFO'] == 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_controller/vendor/rack-0.4.0/rack/auth/openid.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/openid.rb
deleted file mode 100644
index 2bd064ea4a..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/auth/openid.rb
+++ /dev/null
@@ -1,437 +0,0 @@
-# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
-
-gem 'ruby-openid', '~> 2' if defined? Gem
-require 'rack/auth/abstract/handler' #rack
-require 'uri' #std
-require 'pp' #std
-require 'openid' #gem
-require 'openid/extension' #gem
-require 'openid/store/memory' #gem
-
-module Rack
-  module Auth
-    # Rack::Auth::OpenID provides a simple method for permitting
-    # openid based logins. 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
-    # functionality.
-    #
-    # This library strongly intends to utilize the OpenID 2.0 features of the
-    # ruby-openid library, while maintaining OpenID 1.0 compatiblity.
-    #
-    # All responses from this rack application will be 303 redirects unless an
-    # error occurs, with the exception of an authentication request requiring
-    # an HTML form submission.
-    #
-    # NOTE: Extensions are not currently supported by this implimentation of
-    # the OpenID rack application due to the complexity of the current
-    # ruby-openid extension handling.
-    #
-    # NOTE: Due to the amount of data that this library stores in the
-    # session, Rack::Session::Cookie may fault.
-    class OpenID < AbstractHandler
-      class NoSession < RuntimeError; end
-      # Required for ruby-openid
-      OIDStore = ::OpenID::Store::Memory.new
-      HTML = '<html><head><title>%s</title></head><body>%s</body></html>'
-
-      # A Hash of options is taken as it's single initializing
-      # argument. For example:
-      #
-      #   simple_oid = OpenID.new('http://mysite.com/')
-      #
-      #   return_oid = OpenID.new('http://mysite.com/', {
-      #     :return_to => 'http://mysite.com/openid'
-      #   })
-      #
-      #   page_oid = OpenID.new('http://mysite.com/',
-      #     :login_good => 'http://mysite.com/auth_good'
-      #   )
-      #
-      #   complex_oid = OpenID.new('http://mysite.com/',
-      #     :return_to => 'http://mysite.com/openid',
-      #     :login_good => 'http://mysite.com/user/preferences',
-      #     :auth_fail => [500, {'Content-Type'=>'text/plain'},
-      #       'Unable to negotiate with foreign server.'],
-      #     :immediate => true,
-      #     :extensions => {
-      #       ::OpenID::SReg => [['email'],['nickname']]
-      #     }
-      #   )
-      #
-      # = Arguments
-      #
-      # The first argument is the realm, identifying the site they are trusting
-      # with their identity. This is required.
-      #
-      # NOTE: In OpenID 1.x, the realm or trust_root is optional and the
-      # return_to url is required. As this library strives tward ruby-openid
-      # 2.0, and OpenID 2.0 compatibiliy, the realm is required and return_to
-      # is optional. However, this implimentation is still backwards compatible
-      # with OpenID 1.0 servers.
-      #
-      # 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 including all query
-      # parameters.
-      #
-      # <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>:immediate</tt> as true will make immediate type of requests the
-      # default. See OpenID specification documentation.
-      #
-      # === URL options
-      #
-      # <tt>:login_good</tt> is the url to go to after the authentication
-      # process has completed.
-      #
-      # <tt>:login_fail</tt> is the url to go to after the authentication
-      # process has failed.
-      #
-      # <tt>:login_quit</tt> is the url to go to after the authentication
-      # process
-      # has been cancelled.
-      #
-      # === Response options
-      #
-      # <tt>:no_session</tt> should be a rack response to be returned if no or
-      # an incompatible session is found.
-      #
-      # <tt>:auth_fail</tt> should be a rack response to be returned if an
-      # OpenID::DiscoveryFailure occurs. This is typically due to being unable
-      # to access the identity url or identity server.
-      #
-      # <tt>:error</tt> should be a rack response to return if any other
-      # generic error would occur and <tt>options[:catch_errors]</tt> is true.
-      #
-      # === Extensions
-      #
-      # <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.
-      def initialize(realm, options={})
-        @realm = realm
-        realm = URI(realm)
-        if realm.path.empty?
-          raise ArgumentError, "Invalid realm path: '#{realm.path}'"
-        elsif not realm.absolute?
-          raise ArgumentError, "Realm '#{@realm}' not absolute"
-        end
-
-        [:return_to, :login_good, :login_fail, :login_quit].each do |key|
-          if options.key? key and luri = URI(options[key])
-            if !luri.absolute?
-              raise ArgumentError, ":#{key} is not an absolute uri: '#{luri}'"
-            end
-          end
-        end
-
-        if options[:return_to] and ruri = URI(options[:return_to])
-          if ruri.path.empty?
-            raise ArgumentError, "Invalid return_to path: '#{ruri.path}'"
-          elsif realm.path != ruri.path[0, realm.path.size]
-            raise ArgumentError, 'return_to not within realm.' \
-          end
-        end
-
-        # TODO: extension support
-        if extensions = options.delete(:extensions)
-          extensions.each do |ext, args|
-            add_extension ext, *args
-          end
-        end
-
-        @options = {
-          :session_key => 'rack.session',
-          :openid_param => 'openid_identifier',
-          #:return_to, :login_good, :login_fail, :login_quit
-          #:no_session, :auth_fail, :error
-          :store => OIDStore,
-          :immediate => false,
-          :anonymous => false,
-          :catch_errors => false
-        }.merge(options)
-        @extensions = {}
-      end
-
-      attr_reader :options, :extensions
-
-      # It sets up and uses session data at <tt>:openid</tt> within the
-      # session. It sets up the ::OpenID::Consumer using the store specified by
-      # <tt>options[:store]</tt>.
-      #
-      # If the parameter specified by <tt>options[:openid_param]</tt> is
-      # present, processing is passed to #check and the result is returned.
-      #
-      # If the parameter 'openid.mode' is set, implying a followup from the
-      # openid server, processing is passed to #finish and the result is
-      # returned.
-      #
-      # If neither of these conditions are met, a 400 error is returned.
-      #
-      # If an error is thrown and <tt>options[:catch_errors]</tt> is false, the
-      # exception will be reraised. Otherwise a 500 error is returned.
-      def call(env)
-        env['rack.auth.openid'] = self
-        session = env[@options[:session_key]]
-        unless session and session.is_a? Hash
-          raise(NoSession, 'No compatible session')
-        end
-        # let us work in our own namespace...
-        session = (session[:openid] ||= {})
-        unless session and session.is_a? Hash
-          raise(NoSession, 'Incompatible session')
-        end
-
-        request = Rack::Request.new env
-        consumer = ::OpenID::Consumer.new session, @options[:store]
-
-        if request.params['openid.mode']
-          finish consumer, session, request
-        elsif request.params[@options[:openid_param]]
-          check consumer, session, request
-        else
-          env['rack.errors'].puts "No valid params provided."
-          bad_request
-        end
-      rescue NoSession
-        env['rack.errors'].puts($!.message, *$@)
-
-        @options. ### Missing or incompatible session
-          fetch :no_session, [ 500,
-            {'Content-Type'=>'text/plain'},
-            $!.message ]
-      rescue
-        env['rack.errors'].puts($!.message, *$@)
-
-        if not @options[:catch_error]
-          raise($!)
-        end
-        @options.
-          fetch :error, [ 500,
-            {'Content-Type'=>'text/plain'},
-            'OpenID has encountered an error.' ]
-      end
-
-      # As the first part of OpenID consumer action, #check retrieves the data
-      # required for completion.
-      #
-      # * <tt>session[:openid][:openid_param]</tt> is set to the submitted
-      #   identifier to be authenticated.
-      # * <tt>session[:openid][:site_return]</tt> is set as the request's
-      #   HTTP_REFERER, unless already set.
-      # * <tt>env['rack.auth.openid.request']</tt> is the openid checkid
-      #   request instance.
-      def check(consumer, session, req)
-        session[:openid_param]  = req.params[@options[:openid_param]]
-        oid = consumer.begin(session[:openid_param], @options[:anonymous])
-        pp oid if $DEBUG
-        req.env['rack.auth.openid.request'] = oid
-
-        session[:site_return] ||= req.env['HTTP_REFERER']
-
-        # SETUP_NEEDED check!
-        # see OpenID::Consumer::CheckIDRequest docs
-        query_args = [@realm, *@options.values_at(:return_to, :immediate)]
-        query_args[1] ||= req.url
-        query_args[2] = false if session.key? :setup_needed
-        pp query_args if $DEBUG
-
-        ## Extension support
-        extensions.each do |ext,args|
-          oid.add_extension ext::Request.new(*args)
-        end
-
-        if oid.send_redirect?(*query_args)
-          redirect = oid.redirect_url(*query_args)
-          if $DEBUG
-            pp redirect
-            pp Rack::Utils.parse_query(URI(redirect).query)
-          end
-          [ 303, {'Location'=>redirect}, [] ]
-        else
-          # check on 'action' option.
-          formbody = oid.form_markup(*query_args)
-          if $DEBUG
-            pp formbody
-          end
-          body = HTML % ['Confirm...', formbody]
-          [ 200, {'Content-Type'=>'text/html'}, body.to_a ]
-        end
-      rescue ::OpenID::DiscoveryFailure => e
-        # thrown from inside OpenID::Consumer#begin by yadis stuff
-        req.env['rack.errors'].puts($!.message, *$@)
-
-        @options. ### Foreign server failed
-          fetch :auth_fail, [ 503,
-            {'Content-Type'=>'text/plain'},
-            'Foreign server failure.' ]
-      end
-
-      # This is the final portion of authentication. Unless any errors outside
-      # of specification occur, a 303 redirect will be returned with Location
-      # determined by the OpenID response type. If none of the response type
-      # :login_* urls are set, the redirect will be set to
-      # <tt>session[:openid][:site_return]</tt>. If
-      # <tt>session[:openid][:site_return]</tt> is unset, the realm will be
-      # used.
-      #
-      # Any messages from OpenID's response are appended to the 303 response
-      # body.
-      #
-      # Data gathered from extensions are stored in session[:openid] with the
-      # extension's namespace uri as the key.
-      #
-      # * <tt>env['rack.auth.openid.response']</tt> is the openid response.
-      #
-      # The four valid possible outcomes are:
-      # * failure: <tt>options[:login_fail]</tt> or
-      #   <tt>session[:site_return]</tt> or the realm
-      #   * <tt>session[:openid]</tt> is cleared and any messages are send to
-      #     rack.errors
-      #   * <tt>session[:openid]['authenticated']</tt> is <tt>false</tt>
-      # * success: <tt>options[:login_good]</tt> or
-      #   <tt>session[:site_return]</tt> or the realm
-      #   * <tt>session[:openid]</tt> is cleared
-      #   * <tt>session[:openid]['authenticated']</tt> is <tt>true</tt>
-      #   * <tt>session[:openid]['identity']</tt> is the actual identifier
-      #   * <tt>session[:openid]['identifier']</tt> is the pretty identifier
-      # * cancel: <tt>options[:login_good]</tt> or
-      #   <tt>session[:site_return]</tt> or the realm
-      #   * <tt>session[:openid]</tt> is cleared
-      #   * <tt>session[:openid]['authenticated']</tt> is <tt>false</tt>
-      # * setup_needed: resubmits the authentication request. A flag is set for
-      #   non-immediate handling.
-      #   * <tt>session[:openid][:setup_needed]</tt> is set to <tt>true</tt>,
-      #     which will prevent immediate style openid authentication.
-      def finish(consumer, session, req)
-        oid = consumer.complete(req.params, req.url)
-        pp oid if $DEBUG
-        req.env['rack.auth.openid.response'] = oid
-
-        goto = session.fetch :site_return, @realm
-        body = []
-
-        case oid.status
-        when ::OpenID::Consumer::FAILURE
-          session.clear
-          session['authenticated'] = false
-          req.env['rack.errors'].puts oid.message
-
-          goto = @options[:login_fail] if @option.key? :login_fail
-          body << "Authentication unsuccessful.\n"
-        when ::OpenID::Consumer::SUCCESS
-          session.clear
-
-          ## Extension support
-          extensions.each do |ext, args|
-            session[ext::NS_URI] = ext::Response.
-              from_success_response(oid).
-              get_extension_args
-          end
-
-          session['authenticated'] = true
-          # Value for unique identification and such
-          session['identity'] = oid.identity_url
-          # Value for display and UI labels
-          session['identifier'] = oid.display_identifier
-
-          goto = @options[:login_good] if @options.key? :login_good
-          body << "Authentication successful.\n"
-        when ::OpenID::Consumer::CANCEL
-          session.clear
-          session['authenticated'] = false
-
-          goto = @options[:login_fail] if @option.key? :login_fail
-          body << "Authentication cancelled.\n"
-        when ::OpenID::Consumer::SETUP_NEEDED
-          session[:setup_needed] = true
-          unless o_id = session[:openid_param]
-            raise('Required values missing.')
-          end
-
-          goto = req.script_name+
-            '?'+@options[:openid_param]+
-            '='+o_id
-          body << "Reauthentication required.\n"
-        end
-        body << oid.message if oid.message
-        [ 303, {'Location'=>goto}, body]
-      end
-
-      # The first argument should be the main extension module.
-      # The extension module should contain the constants:
-      #   * class Request, with OpenID::Extension as an ancestor
-      #   * class Response, with OpenID::Extension as an ancestor
-      #   * string NS_URI, which defines the namespace of the extension, should
-      #     be an absolute http uri
-      #
-      # 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
-        if not ext.is_a? Module
-          raise TypeError, "#{ext.inspect} is not a module"
-        elsif not (m = %w'Request Response NS_URI' - ext.constants).empty?
-          raise ArgumentError, "#{ext.inspect} missing #{m*', '}"
-        end
-
-        consts = [ext::Request, ext::Response]
-
-        if not consts.all?{|c| c.is_a? Class }
-          raise TypeError, "#{ext.inspect}'s Request or Response is not a class"
-        elsif not consts.all?{|c| ::OpenID::Extension > c }
-          raise ArgumentError, "#{ext.inspect}'s Request or Response not a decendant of OpenID::Extension"
-        end
-
-        if not ext::NS_URI.is_a? String
-          raise TypeError, "#{ext.inspect}'s NS_URI is not a string"
-        elsif not uri = URI(ext::NS_URI)
-          raise ArgumentError, "#{ext.inspect}'s NS_URI is not a valid uri"
-        elsif not uri.scheme =~ /^https?$/
-          raise ArgumentError, "#{ext.inspect}'s NS_URI is not an http uri"
-        elsif not uri.absolute?
-          raise ArgumentError, "#{ext.inspect}'s NS_URI is not and absolute uri"
-        end
-        @extensions[ext] = args
-        return ext::NS_URI
-      end
-
-      # A conveniance method that returns the namespace of all current
-      # extensions used by this instance.
-      def extension_namespaces
-        @extensions.keys.map{|e|e::NS_URI}
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/builder.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/builder.rb
deleted file mode 100644
index e708b52aee..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/builder.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-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
-  #  }
-  #
-  # +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 use(middleware, *args, &block)
-      @ins << if block_given?
-        lambda { |app| middleware.new(app, *args, &block) }
-      else
-        lambda { |app| middleware.new(app, *args) }
-      end
-    end
-
-    def run(app)
-      @ins << app #lambda { |nothing| app }
-    end
-
-    def map(path, &block)
-      if @ins.last.kind_of? Hash
-        @ins.last[path] = Rack::Builder.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_controller/vendor/rack-0.4.0/rack/cascade.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/cascade.rb
deleted file mode 100644
index a038aa1105..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/cascade.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/commonlogger.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/commonlogger.rb
deleted file mode 100644
index 5e68ac626d..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/commonlogger.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/deflater.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/deflater.rb
deleted file mode 100644
index 1341eecec2..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/deflater.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-require "zlib"
-require "stringio"
-
-module Rack
-
-class Deflater
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    status, headers, body = @app.call(env)
-
-    request = Request.new(env)
-
-    encoding = Utils.select_best_encoding(%w(gzip deflate identity), request.accept_encoding)
-
-    case encoding
-    when "gzip"
-      mtime = headers["Last-Modified"] || Time.now
-      [status, headers.merge("Content-Encoding" => "gzip"), self.class.gzip(body, mtime)]
-    when "deflate"
-      [status, headers.merge("Content-Encoding" => "deflate"), self.class.deflate(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"}, message]
-    end
-  end
-
-  def self.gzip(body, mtime)
-    io = StringIO.new
-    gzip = Zlib::GzipWriter.new(io)
-    gzip.mtime = mtime
-
-    # TODO: Add streaming
-    body.each { |part| gzip << part }
-
-    gzip.close
-    return io.string
-  end
-
-  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
-  ]
-
-  # Loosely based on Mongrel's Deflate handler
-  def self.deflate(body)
-    deflater = Zlib::Deflate.new(*DEFLATE_ARGS)
-
-    # TODO: Add streaming
-    body.each { |part| deflater << part }
-
-    return deflater.finish
-  end
-end
-
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/directory.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/directory.rb
deleted file mode 100644
index 31e0db8449..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/directory.rb
+++ /dev/null
@@ -1,158 +0,0 @@
-require 'time'
-
-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>
-  <style type='text/css'>
-table { width:100%%; }
-.name { text-align:left; }
-.size, .mtime { text-align:right; }
-  </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 = root
-      @app = app
-      unless defined? @app
-        @app = Rack::File.new(@root)
-      end
-    end
-
-    def call(env)
-      dup._call(env)
-    end
-
-    F = ::File
-
-    def _call(env)
-      if env["PATH_INFO"].include? ".."
-        body = "Forbidden\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
-      end
-
-      @path = F.join(@root, Utils.unescape(env['PATH_INFO']))
-
-      if F.exist?(@path) and F.readable?(@path)
-        if F.file?(@path)
-          return @app.call(env)
-        elsif F.directory?(@path)
-          @files = [['../','Parent Directory','','','']]
-          sName, pInfo = env.values_at('SCRIPT_NAME', 'PATH_INFO')
-          Dir.entries(@path).sort.each do |file|
-            next if file[0] == ?.
-            fl    = F.join(@path, file)
-            sz    = F.size(fl)
-            url   = F.join(sName, pInfo, file)
-            type  = F.directory?(fl) ? 'directory' :
-              MIME_TYPES.fetch(F.extname(file)[1..-1],'unknown')
-            size  = (type!='directory' ? (sz<10240 ? "#{sz}B" : "#{sz/1024}KB") : '-')
-            mtime = F.mtime(fl).httpdate
-            @files << [ url, file, size, type, mtime ]
-          end
-          return [ 200, {'Content-Type'=>'text/html'}, self ]
-        end
-      end
-
-      body = "Entity not found: #{env["PATH_INFO"]}\n"
-      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-      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
-
-    def each_entry
-      @files.each{|e| yield e }
-    end
-
-    # From WEBrick.
-    MIME_TYPES = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "js"    => "text/javascript",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/file.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/file.rb
deleted file mode 100644
index afb213836c..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/file.rb
+++ /dev/null
@@ -1,116 +0,0 @@
-require 'time'
-
-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
-
-    def initialize(root)
-      @root = root
-    end
-
-    def call(env)
-      dup._call(env)
-    end
-
-    F = ::File
-
-    def _call(env)
-      if env["PATH_INFO"].include? ".."
-        body = "Forbidden\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
-      end
-
-      @path = F.join(@root, Utils.unescape(env["PATH_INFO"]))
-      ext = F.extname(@path)[1..-1]
-
-      if F.file?(@path) && F.readable?(@path)
-        [200, {
-           "Last-Modified"  => F.mtime(@path).httpdate,
-           "Content-Type"   => MIME_TYPES[ext] || "text/plain",
-           "Content-Length" => F.size(@path).to_s
-         }, self]
-      else
-        body = "File not found: #{env["PATH_INFO"]}\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
-      end
-    end
-
-    def each
-      F.open(@path, "rb") { |file|
-        while part = file.read(8192)
-          yield part
-        end
-      }
-    end
-
-    # :stopdoc:
-    # From WEBrick with some additions.
-    MIME_TYPES = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "js"    => "text/javascript",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mp3"   => "audio/mpeg",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
-    # :startdoc:
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler.rb
deleted file mode 100644
index debd15d66e..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-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
-
-      if klass = @handlers[server]
-        obj = Object
-        klass.split("::").each { |x| obj = obj.const_get(x) }
-        obj
-      else
-        Rack::Handler.const_get(server.capitalize)
-      end
-    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 :WEBrick, "rack/handler/webrick"
-    autoload :LSWS, "rack/handler/lsws"
-    autoload :SCGI, "rack/handler/scgi"
-
-    register 'cgi', 'Rack::Handler::CGI'
-    register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'mongrel', 'Rack::Handler::Mongrel'
-    register 'emongrel', 'Rack::Handler::EventedMongrel'
-    register 'webrick', 'Rack::Handler::WEBrick'
-    register 'lsws', 'Rack::Handler::LSWS'
-    register 'scgi', 'Rack::Handler::SCGI'
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/cgi.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/cgi.rb
deleted file mode 100644
index 1922402c8c..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/cgi.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-module Rack
-  module Handler
-    class CGI
-      def self.run(app, options=nil)
-        serve app
-      end
-
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        env.update({"rack.version" => [0,1],
-                     "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.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_controller/vendor/rack-0.4.0/rack/handler/evented_mongrel.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/evented_mongrel.rb
deleted file mode 100644
index 1eb5eb909b..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/evented_mongrel.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-require 'swiftcore/evented_mongrel'
-
-module Rack
-  module Handler
-    class EventedMongrel < Mongrel
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/fastcgi.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/fastcgi.rb
deleted file mode 100644
index 5f8801d516..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/fastcgi.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-require 'fcgi'
-require 'socket'
-
-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
-
-      module ProperStream       # :nodoc:
-        def each                # This is missing by default.
-          while line = gets
-            yield line
-          end
-        end
-
-        def read(*args)
-          if args.empty?
-            super || ""           # Empty string on EOF.
-          else
-            super
-          end
-        end
-      end
-
-      def self.serve(request, app)
-        env = request.env
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        request.in.extend ProperStream
-
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        env.update({"rack.version" => [0,1],
-                     "rack.input" => request.in,
-                     "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"] == ""
-
-        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
-          request.finish
-        end
-      end
-
-      def self.send_headers(out, status, headers)
-        out.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.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_controller/vendor/rack-0.4.0/rack/handler/lsws.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/lsws.rb
deleted file mode 100644
index 48b82b5861..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/lsws.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-require 'lsapi'
-#require 'cgi'
-module Rack
-  module Handler
-    class LSWS
-      def self.run(app, options=nil)
-        while LSAPI.accept != nil
-          serve app
-        end
-      end
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
-        env.update({"rack.version" => [0,1],
-                     "rack.input" => STDIN,
-                     "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.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_controller/vendor/rack-0.4.0/rack/handler/mongrel.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/mongrel.rb
deleted file mode 100644
index 8bdd6b7c44..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/mongrel.rb
+++ /dev/null
@@ -1,78 +0,0 @@
-require 'mongrel'
-require 'stringio'
-
-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 = 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" => [0,1],
-                     "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
-          headers.each { |k, vs|
-            vs.each { |v|
-              response.header[k] = v
-            }
-          }
-          body.each { |part|
-            response.body << part
-          }
-          response.finished
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/scgi.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/scgi.rb
deleted file mode 100644
index 0e143395b9..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/scgi.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-require 'scgi'
-require 'stringio'
-
-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 = 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" => [0,1],
-                     "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.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_controller/vendor/rack-0.4.0/rack/handler/webrick.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/webrick.rb
deleted file mode 100644
index c3222fdcc5..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/handler/webrick.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-require 'webrick'
-require 'stringio'
-
-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 = app
-      end
-
-      def service(req, res)
-        env = req.meta_vars
-        env.delete_if { |k, v| v.nil? }
-
-        env.update({"rack.version" => [0,1],
-                     "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"] ||= "/"
-        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
-
-        status, headers, body = @app.call(env)
-        begin
-          res.status = status.to_i
-          headers.each { |k, vs|
-            vs.each { |v|
-              res[k] = v
-            }
-          }
-          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_controller/vendor/rack-0.4.0/rack/lint.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/lint.rb
deleted file mode 100644
index 7bc433b863..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/lint.rb
+++ /dev/null
@@ -1,401 +0,0 @@
-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
-      [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.
-
-      ## <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 [0,1], 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).
-
-      ## 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 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 one of +GET+, +POST+, +PUT+,
-      ##   +DELETE+, +HEAD+, +OPTIONS+, +TRACE+.
-      assert("REQUEST_METHOD unknown: #{env["REQUEST_METHOD"]}") {
-        %w[GET POST PUT DELETE
-           HEAD OPTIONS TRACE].include?(env["REQUEST_METHOD"])
-      }
-
-      ## * 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
-    def check_input(input)
-      ## The input stream must respond to +gets+, +each+ and +read+.
-      [:gets, :each, :read].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
-
-      ## * +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+ must be called without or with one integer argument
-      ##   and return a string, or +nil+ on EOF.
-      def read(*args)
-        assert("rack.input#read called with too many arguments") {
-          args.size <= 1
-        }
-        if args.size == 1
-          assert("rack.input#read called with non-integer argument") {
-            args.first.kind_of? Integer
-          }
-        end
-        v = @input.read(*args)
-        assert("rack.input#read didn't return a String") {
-          v.nil? or v.instance_of? String
-        }
-        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
-
-      ## * +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)
-      ## The status, if parsed as integer (+to_i+), 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 respond to #each.
-        assert("header values must respond to #each, but the value of " +
-          "'#{key}' doesn't (is #{value.class})") { value.respond_to? :each }
-        value.each { |item|
-          ## The values passed on #each must be Strings
-          assert("header values must consist of Strings, but '#{key}' also contains a #{item.class}") {
-            item.instance_of?(String)
-          }
-          ## and 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 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 [204, 304].include? status.to_i
-          }
-          return
-        end
-      }
-      assert("No Content-Type header found") {
-        [204, 304].include? status.to_i
-      }
-    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
-      }
-      ##
-      ## If the Body responds to #close, it will be called after iteration.
-      # XXX howto: assert("Body has not been closed") { @closed }
-
-      ##
-      ## 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_controller/vendor/rack-0.4.0/rack/lobster.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/lobster.rb
deleted file mode 100644
index 33f6b81b01..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/lobster.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-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
-
-      [200, {"Content-Type" => "text/html"},
-       ["<title>Lobstericious!</title>",
-        "<pre>", lobster, "</pre>",
-        "<a href='#{href}'>flip!</a>"]
-      ]
-    }
-
-    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
-
-      Response.new.finish do |res|
-        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>"
-      end
-    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_controller/vendor/rack-0.4.0/rack/mock.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/mock.rb
deleted file mode 100644
index f43b9af3ef..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/mock.rb
+++ /dev/null
@@ -1,160 +0,0 @@
-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" => [0,1],
-      "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)
-      env = DEFAULT_ENV.dup
-
-      env["REQUEST_METHOD"] = opts[:method] || "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["SCRIPT_NAME"] = opts[:script_name] || ""
-
-      if opts[:fatal]
-        env["rack.errors"] = FatalWarner.new
-      else
-        env["rack.errors"] = StringIO.new
-      end
-
-      opts[:input] ||= ""
-      if String === opts[:input]
-        env["rack.input"] = StringIO.new(opts[:input])
-      else
-        env["rack.input"] = opts[:input]
-      end
-
-      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|
-        values.each { |value|
-          @headers[field] = value
-        }
-        @headers[field] = ""  if values.empty?
-      }
-
-      @body = ""
-      body.each { |part| @body << part }
-
-      @errors = errors.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_controller/vendor/rack-0.4.0/rack/recursive.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/recursive.rb
deleted file mode 100644
index bf8b965925..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/recursive.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/reloader.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/reloader.rb
deleted file mode 100644
index 25ca2f9e85..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/reloader.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-require 'thread'
-
-module Rack
-  # Rack::Reloader checks on every request, but at most every +secs+
-  # seconds, if a file loaded changed, and reloads it, logging to
-  # rack.errors.
-  #
-  # It is recommended you use ShowExceptions to catch SyntaxErrors etc.
-
-  class Reloader
-    def initialize(app, secs=10)
-      @app = app
-      @secs = secs              # reload every @secs seconds max
-      @last = Time.now
-    end
-
-    def call(env)
-      if Time.now > @last + @secs
-        Thread.exclusive {
-          reload!(env['rack.errors'])
-          @last = Time.now
-        }
-      end
-
-      @app.call(env)
-    end
-
-    def reload!(stderr=STDERR)
-      need_reload = $LOADED_FEATURES.find_all { |loaded|
-        begin
-          if loaded =~ /\A[.\/]/  # absolute filename or 1.9
-            abs = loaded
-          else
-            abs = $LOAD_PATH.map { |path| ::File.join(path, loaded) }.
-                             find { |file| ::File.exist? file }
-          end
-
-          if abs
-            ::File.mtime(abs) > @last - @secs  rescue false
-          else
-            false
-          end
-        end
-      }
-
-      need_reload.each { |l|
-        $LOADED_FEATURES.delete l
-      }
-
-      need_reload.each { |to_load|
-        begin
-          if require to_load
-            stderr.puts "#{self.class}: reloaded `#{to_load}'"
-          end
-        rescue LoadError, SyntaxError => e
-          raise e                 # Possibly ShowExceptions
-        end
-      }
-
-      stderr.flush
-      need_reload
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/request.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/request.rb
deleted file mode 100644
index 2a9bcc15b9..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/request.rb
+++ /dev/null
@@ -1,209 +0,0 @@
-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"]
-
-  class Request
-    # The environment of the request.
-    attr_reader :env
-
-    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
-
-    # 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)[0].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'
-    ]
-
-    # 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
-
-    # 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_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?
-        @env["rack.request.form_input"] = @env["rack.input"]
-        unless @env["rack.request.form_hash"] =
-            Utils::Multipart.parse_multipart(env)
-          @env["rack.request.form_vars"] = @env["rack.input"].read
-          @env["rack.request.form_hash"] = Utils.parse_query(@env["rack.request.form_vars"])
-        end
-        @env["rack.request.form_hash"]
-      else
-        {}
-      end
-    end
-
-    # The union of GET and POST data.
-    def params
-      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 fullpath
-      path = script_name + path_info
-      path << "?" << query_string  unless query_string.empty?
-      path
-    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
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/response.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/response.rb
deleted file mode 100644
index 3ae095f257..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/response.rb
+++ /dev/null
@@ -1,166 +0,0 @@
-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
-    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
-
-      @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]
-        value = value[:value]
-      end
-      value = [value]  unless Array === value
-      cookie = Utils.escape(key) + "=" +
-        value.map { |v| Utils.escape v }.join("&") +
-        "#{domain}#{path}#{expires}"
-
-      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 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
-
-    def write(str)
-      @writer.call str.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_controller/vendor/rack-0.4.0/rack/session/abstract/id.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/abstract/id.rb
deleted file mode 100644
index c220b2cb8d..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/abstract/id.rb
+++ /dev/null
@@ -1,140 +0,0 @@
-# AUTHOR: blink <blinketje@gmail.com>; blink#ruby-lang@irc.freenode.net
-# bugrep: Andreas Zehnder
-
-require 'rack/utils'
-require 'time'
-
-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 should
-      # need to be overwritten.
-      #
-      # All parameters are optional.
-      # * :key determines the name of the cookie, by default it is
-      #   'rack.session'
-      # * :domain and :path set the related cookie values, by default
-      #   domain is nil, and the path is '/'.
-      # * :expire_after is the number of seconds in which the session
-      #   cookie will expire. By default it is set not to provide any
-      #   expiry time.
-      class ID
-        attr_reader :key
-        DEFAULT_OPTIONS = {
-          :key =>           'rack.session',
-          :path =>          '/',
-          :domain =>        nil,
-          :expire_after =>  nil
-        }
-
-        def initialize(app, options={})
-          @default_options = self.class::DEFAULT_OPTIONS.merge(options)
-          @key = @default_options[:key]
-          @default_context = context app
-        end
-
-        def call(env)
-          @default_context.call(env)
-        end
-
-        def context(app)
-          Rack::Utils::Context.new self, app do |env|
-            load_session env
-            response = app.call(env)
-            commit_session env, response
-            response
-          end
-        end
-
-        private
-
-        # 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)
-          sid           = (env['HTTP_COOKIE']||'')[/#{@key}=([^,;]+)/,1]
-          sid, session  = get_session(env, sid)
-          unless session.is_a?(Hash)
-            puts 'Session: '+sid.inspect+"\n"+session.inspect if $DEBUG
-            raise TypeError, 'Session not a Hash'
-          end
-
-          options = @default_options.
-            merge({ :id => sid, :by => self, :at => Time.now })
-
-          env['rack.session'] = session
-          env['rack.session.options'] = options
-
-          return true
-        end
-
-        # Acquires the session from the environment and the session id from
-        # the session options and passes them to #set_session. It then
-        # proceeds to set a cookie up in the response with the session's id.
-        def commit_session(env, response)
-          unless response.is_a?(Array)
-            puts 'Response: '+response.inspect if $DEBUG
-            raise ArgumentError, 'Response is not an array.'
-          end
-
-          options = env['rack.session.options']
-          unless options.is_a?(Hash)
-            puts 'Options: '+options.inspect if $DEBUG
-            raise TypeError, 'Options not a Hash'
-          end
-
-          sid, time, z = options.values_at(:id, :at, :by)
-          unless self == z
-            warn "#{self} not managing this session."
-            return
-          end
-
-          unless env['rack.session'].is_a?(Hash)
-            warn 'Session: '+sid.inspect+"\n"+session.inspect if $DEBUG
-            raise TypeError, 'Session not a Hash'
-          end
-
-          unless set_session(env, sid)
-            warn "Session not saved." if $DEBUG
-            warn "#{env['rack.session'].inspect} has been lost."if $DEBUG
-            return false
-          end
-
-          cookie = Utils.escape(@key)+'='+Utils.escape(sid)
-          cookie<< "; domain=#{options[:domain]}" if options[:domain]
-          cookie<< "; path=#{options[:path]}" if options[:path]
-          if options[:expire_after]
-            expiry = time + options[:expire_after]
-            cookie<< "; expires=#{expiry.httpdate}"
-          end
-
-          case a = (h = response[1])['Set-Cookie']
-          when Array then  a << cookie
-          when String then h['Set-Cookie'] = [a, cookie]
-          when nil then    h['Set-Cookie'] = cookie
-          end
-
-          return true
-        end
-
-        # Should return [session_id, session]. All thread safety and session
-        # retrival proceedures should occur here.
-        # 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 needs to be 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)
-          raise '#set_session needs to be implemented.'
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/cookie.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/cookie.rb
deleted file mode 100644
index 154a87c3ea..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/cookie.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-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).
-    #
-    # Example:
-    #
-    #     use Rack::Session::Cookie, :key => 'rack.session',
-    #                                :domain => 'foo.com',
-    #                                :path => '/',
-    #                                :expire_after => 2592000
-    #
-    #     All parameters are optional.
-
-    class Cookie
-
-      def initialize(app, options={})
-        @app = app
-        @key = options[:key] || "rack.session"
-        @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]
-
-        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 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
-
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/memcache.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/memcache.rb
deleted file mode 100644
index 7cda9d8697..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/memcache.rb
+++ /dev/null
@@ -1,97 +0,0 @@
-# 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
-        @pool = MemCache.new @default_options[:memcache_server], @default_options
-        unless @pool.servers.any?{|s|s.alive?}
-          raise "#{self} unable to find server during initialization."
-        end
-        @mutex = Mutex.new
-      end
-
-      private
-
-      def get_session(env, sid)
-        session = sid && @pool.get(sid)
-        unless session and session.is_a?(Hash)
-          session = {}
-          lc = 0
-          @mutex.synchronize do
-            begin
-              raise RuntimeError, 'Unique id finding looping excessively' if (lc+=1) > 1000
-              sid = "%08x" % rand(0xffffffff)
-              ret = @pool.add(sid, session)
-            end until /^STORED/ =~ ret
-          end
-        end
-        class << session
-          @deleted = []
-          def delete key
-            (@deleted||=[]) << key
-            super
-          end
-        end
-        [sid, session]
-      rescue MemCache::MemCacheError, Errno::ECONNREFUSED # MemCache server cannot be contacted
-        warn "#{self} is unable to find server."
-        warn $!.inspect
-        return [ nil, {} ]
-      end
-
-      def set_session(env, sid)
-        session = env['rack.session']
-        options = env['rack.session.options']
-        expiry  = options[:expire_after] || 0
-        o, s = @mutex.synchronize do
-          old_session = @pool.get(sid)
-          unless old_session.is_a?(Hash)
-            warn 'Session not properly initialized.' if $DEBUG
-            old_session = {}
-            @pool.add sid, old_session, expiry
-          end
-          session.instance_eval do
-            @deleted.each{|k| old_session.delete(k) } if defined? @deleted
-          end
-          @pool.set sid, old_session.merge(session), expiry
-          [old_session, session]
-        end
-        s.each do |k,v|
-          next unless o.has_key?(k) and v != o[k]
-          warn "session value assignment collision at #{k.inspect}:"+
-            "\n\t#{o[k].inspect}\n\t#{v.inspect}"
-        end if $DEBUG and env['rack.multithread']
-        return true
-      rescue MemCache::MemCacheError, Errno::ECONNREFUSED # MemCache server cannot be contacted
-        warn "#{self} is unable to find server."
-        warn $!.inspect
-        return false
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/pool.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/pool.rb
deleted file mode 100644
index 6e5e788210..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/session/pool.rb
+++ /dev/null
@@ -1,73 +0,0 @@
-# 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.
-    #
-    # Example:
-    #   myapp = MyRackApp.new
-    #   sessioned = Rack::Session::Pool.new(myapp,
-    #     :key => 'rack.session',
-    #     :domain => 'foo.com',
-    #     :path => '/',
-    #     :expire_after => 2592000
-    #   )
-    #   Rack::Handler::WEBrick.run sessioned
-
-    class Pool < Abstract::ID
-      attr_reader :mutex, :pool
-      DEFAULT_OPTIONS = Abstract::ID::DEFAULT_OPTIONS.dup
-
-      def initialize(app, options={})
-        super
-        @pool = Hash.new
-        @mutex = Mutex.new
-      end
-
-      private
-
-      def get_session(env, sid)
-        session = @mutex.synchronize do
-          unless sess = @pool[sid] and ((expires = sess[:expire_at]).nil? or expires > Time.now)
-            @pool.delete_if{|k,v| expiry = v[:expire_at] and expiry < Time.now }
-            begin
-              sid = "%08x" % rand(0xffffffff)
-            end while @pool.has_key?(sid)
-          end
-          @pool[sid] ||= {}
-        end
-        [sid, session]
-      end
-
-      def set_session(env, sid)
-        options = env['rack.session.options']
-        expiry = options[:expire_after] && options[:at]+options[:expire_after]
-        @mutex.synchronize do
-          old_session = @pool[sid]
-          old_session[:expire_at] = expiry if expiry
-          session = old_session.merge(env['rack.session'])
-          @pool[sid] = session
-          session.each do |k,v|
-            next unless old_session.has_key?(k) and v != old_session[k]
-            warn "session value assignment collision at #{k}: #{old_session[k]} <- #{v}"
-          end if $DEBUG and env['rack.multithread']
-        end
-        return true
-      rescue
-        warn "#{self} is unable to find server."
-        warn "#{env['rack.session'].inspect} has been lost."
-        warn $!.inspect
-        return false
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/showexceptions.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/showexceptions.rb
deleted file mode 100644
index 1c85dec19a..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/showexceptions.rb
+++ /dev/null
@@ -1,344 +0,0 @@
-require 'ostruct'
-require 'erb'
-require 'rack/request'
-
-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
-      [500, {"Content-Type" => "text/html"}, pretty(env, e)]
-    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::ShowException</code>.
-  </p>
-</div>
-
-</body>
-</html>
-HTML
-
-    # :startdoc:
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/showstatus.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/showstatus.rb
deleted file mode 100644
index ca81f7d83f..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/showstatus.rb
+++ /dev/null
@@ -1,105 +0,0 @@
-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)
-
-      # client or server error, or explicit message
-      if status.to_i >= 400 &&
-          (body.empty? rescue false) || 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 = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        [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_controller/vendor/rack-0.4.0/rack/static.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/static.rb
deleted file mode 100644
index 168e8f83b2..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/static.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-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_controller/vendor/rack-0.4.0/rack/urlmap.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/urlmap.rb
deleted file mode 100644
index b00f2d7a19..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/urlmap.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-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)
-      @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)| -l.size }  # Longest path first
-    end
-
-    def call(env)
-      path = env["PATH_INFO"].to_s.squeeze("/")
-      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] == ?/
-        env["SCRIPT_NAME"] += location
-        env["PATH_INFO"]    = path[location.size..-1]
-        return app.call(env)
-      }
-      [404, {"Content-Type" => "text/plain"}, ["Not Found: #{path}"]]
-    end
-  end
-end
-
diff --git a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/utils.rb b/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/utils.rb
deleted file mode 100644
index 25254bbdf2..0000000000
--- a/actionpack/lib/action_controller/vendor/rack-0.4.0/rack/utils.rb
+++ /dev/null
@@ -1,318 +0,0 @@
-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 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
-
-    # 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
-
-    # The recommended manner in which to implement a contexting application
-    # is to define a method #context in which a new Context is instantiated.
-    #
-    # As a Context is a glorified block, it is highly recommended that you
-    # define the contextual block within the application's operational scope.
-    # This would typically the application as you're place into Rack's stack.
-    #
-    #   class MyObject
-    #     ...
-    #     def context app
-    #       Rack::Utils::Context.new app do |env|
-    #         do_stuff
-    #         response = app.call(env)
-    #         do_more_stuff
-    #       end
-    #     end
-    #     ...
-    #   end
-    #
-    # mobj = MyObject.new
-    # app = mobj.context other_app
-    # Rack::Handler::Mongrel.new app
-    class Context < Proc
-      alias_method :old_inspect, :inspect
-      attr_reader :for, :app
-      def initialize app_f, app_r
-        raise 'running context not provided' unless app_f
-        raise 'running context does not respond to #context' unless app_f.respond_to? :context
-        raise 'application context not provided' unless app_r
-        raise 'application context does not respond to #call' unless app_r.respond_to? :call
-        @for = app_f
-        @app = app_r
-      end
-      def inspect
-        "#{old_inspect} ==> #{@for.inspect} ==> #{@app.inspect}"
-      end
-      def context app_r
-        raise 'new application context not provided' unless app_r
-        raise 'new application context does not respond to #call' unless app_r.respond_to? :call
-        @for.context app_r
-      end
-      def pretty_print pp
-        pp.text old_inspect
-        pp.nest 1 do
-          pp.breakable
-          pp.text '=for> '
-          pp.pp @for
-          pp.breakable
-          pp.text '=app> '
-          pp.pp @app
-        end
-      end
-    end
-
-    # A case-normalizing Hash, adjusting on [] and []=.
-    class HeaderHash < Hash
-      def initialize(hash={})
-        hash.each { |k, v| self[k] = v }
-      end
-
-      def to_hash
-        {}.replace(self)
-      end
-
-      def [](k)
-        super capitalize(k)
-      end
-
-      def []=(k, v)
-        super capitalize(k), v
-      end
-
-      def capitalize(k)
-        k.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }
-      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  => 'Moved Temporarily',
-      303  => 'See Other',
-      304  => 'Not Modified',
-      305  => 'Use Proxy',
-      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 Time-out',
-      409  => 'Conflict',
-      410  => 'Gone',
-      411  => 'Length Required',
-      412  => 'Precondition Failed',
-      413  => 'Request Entity Too Large',
-      414  => 'Request-URI Too Large',
-      415  => 'Unsupported Media Type',
-      500  => 'Internal Server Error',
-      501  => 'Not Implemented',
-      502  => 'Bad Gateway',
-      503  => 'Service Unavailable',
-      504  => 'Gateway Time-out',
-      505  => 'HTTP Version not supported'
-    }
-
-    # A multipart form data parser, adapted from IOWA.
-    #
-    # Usually, Rack::Request#POST takes care of calling this.
-
-    module Multipart
-      EOL = "\r\n"
-
-      def self.parse_multipart(env)
-        unless env['CONTENT_TYPE'] =~
-            %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n
-          nil
-        else
-          boundary = "--#{$1}"
-
-          params = {}
-          buf = ""
-          content_length = env['CONTENT_LENGTH'].to_i
-          input = env['rack.input']
-
-          boundary_size = boundary.size + EOL.size
-          bufsize = 16384
-
-          content_length -= boundary_size
-
-          status = input.read(boundary_size)
-          raise EOFError, "bad content body"  unless status == boundary + EOL
-
-          rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/
-
-          loop {
-            head = nil
-            body = ''
-            filename = content_type = name = nil
-
-            until head && buf =~ rx
-              if !head && i = buf.index("\r\n\r\n")
-                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: (.*)\r\n/ni, 1]
-                name = head[/Content-Disposition:.* name="?([^\";]*)"?/ni, 1]
-
-                if 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)
-              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
-              body.rewind
-              data = {:filename => filename, :type => content_type,
-                      :name => name, :tempfile => body, :head => head}
-            else
-              data = body
-            end
-
-            if name
-              if name =~ /\[\]\z/
-                params[name] ||= []
-                params[name] << data
-              else
-                params[name] = data
-              end
-            end
-
-            break  if buf.empty? || content_length == -1
-          }
-
-          params
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/vendor/rack.rb b/actionpack/lib/action_controller/vendor/rack.rb
deleted file mode 100644
index 2438059f76..0000000000
--- a/actionpack/lib/action_controller/vendor/rack.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-require 'rubygems'
-
-begin
-  gem 'rack', '~> 0.4.0'
-  require 'rack'
-rescue Gem::LoadError
-  $LOAD_PATH << "#{File.dirname(__FILE__)}/rack-0.4.0"
-  require 'rack'
-end