rack 1.6.13 → 2.0.9

data/lib/rack/utils.rb

@@ -1,35 +1,28 @@
 # -*- encoding: binary -*-
+require 'uri'
 require 'fileutils'
 require 'set'
 require 'tempfile'
-require 'rack/multipart'
+require 'rack/query_parser'
 require 'time'
 
-major, minor, patch = RUBY_VERSION.split('.').map { |v| v.to_i }
-
-if major == 1 && minor < 9
-  require 'rack/backports/uri/common_18'
-elsif major == 1 && minor == 9 && patch == 2 && RUBY_PATCHLEVEL <= 328 && RUBY_ENGINE != 'jruby'
-  require 'rack/backports/uri/common_192'
-elsif major == 1 && minor == 9 && patch == 3 && RUBY_PATCHLEVEL < 125
-  require 'rack/backports/uri/common_193'
-else
-  require 'uri/common'
-end
-
 module Rack
   # Rack::Utils contains a grab-bag of useful methods for writing web
   # applications adopted from all kinds of Ruby libraries.
 
   module Utils
-    # ParameterTypeError is the error that is raised when incoming structural
-    # parameters (parsed by parse_nested_query) contain conflicting types.
-    class ParameterTypeError < TypeError; end
+    ParameterTypeError = QueryParser::ParameterTypeError
+    InvalidParameterError = QueryParser::InvalidParameterError
+    DEFAULT_SEP = QueryParser::DEFAULT_SEP
+    COMMON_SEP = QueryParser::COMMON_SEP
+    KeySpaceConstrainedParams = QueryParser::Params
 
-    # InvalidParameterError is the error that is raised when incoming structural
-    # parameters (parsed by parse_nested_query) contain invalid format or byte
-    # sequence.
-    class InvalidParameterError < ArgumentError; end
+    class << self
+      attr_accessor :default_query_parser
+    end
+    # The default number of bytes to allow parameter keys to take up.
+    # This helps prevent a rogue client from flooding a Request.
+    self.default_query_parser = QueryParser.make_default(65536, 100)
 
     # URI escapes. (CGI style space to +)
     def escape(s)
@@ -40,137 +33,70 @@ module Rack
     # Like URI escaping, but with %20 instead of +. Strictly speaking this is
     # true URI escaping.
     def escape_path(s)
-      escape(s).gsub('+', '%20')
+      ::URI::DEFAULT_PARSER.escape s
     end
     module_function :escape_path
 
+    # Unescapes the **path** component of a URI.  See Rack::Utils.unescape for
+    # unescaping query parameters or form components.
+    def unescape_path(s)
+      ::URI::DEFAULT_PARSER.unescape s
+    end
+    module_function :unescape_path
+
+
     # Unescapes a URI escaped string with +encoding+. +encoding+ will be the
     # target encoding of the string returned, and it defaults to UTF-8
-    if defined?(::Encoding)
-      def unescape(s, encoding = Encoding::UTF_8)
-        URI.decode_www_form_component(s, encoding)
-      end
-    else
-      def unescape(s, encoding = nil)
-        URI.decode_www_form_component(s, encoding)
-      end
+    def unescape(s, encoding = Encoding::UTF_8)
+      URI.decode_www_form_component(s, encoding)
     end
     module_function :unescape
 
-    DEFAULT_SEP = /[&;] */n
-
     class << self
-      attr_accessor :key_space_limit
-      attr_accessor :param_depth_limit
       attr_accessor :multipart_part_limit
     end
 
-    # The default number of bytes to allow parameter keys to take up.
-    # This helps prevent a rogue client from flooding a Request.
-    self.key_space_limit = 65536
-
-    # Default depth at which the parameter parser will raise an exception for
-    # being too deep.  This helps prevent SystemStackErrors
-    self.param_depth_limit = 100
-
     # The maximum number of parts a request can contain. Accepting too many part
     # can lead to the server running out of file handles.
     # Set to `0` for no limit.
-    # FIXME: RACK_MULTIPART_LIMIT was introduced by mistake and it will be removed in 1.7.0
-    self.multipart_part_limit = (ENV['RACK_MULTIPART_PART_LIMIT'] || ENV['RACK_MULTIPART_LIMIT'] || 128).to_i
-
-    # 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 = nil, &unescaper)
-      unescaper ||= method(:unescape)
-
-      params = KeySpaceConstrainedParams.new
-
-      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
-        next if p.empty?
-        k, v = p.split('=', 2).map(&unescaper)
+    self.multipart_part_limit = (ENV['RACK_MULTIPART_PART_LIMIT'] || 128).to_i
 
-        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.to_params_hash
+    def self.param_depth_limit
+      default_query_parser.param_depth_limit
     end
-    module_function :parse_query
-
-    # parse_nested_query expands a query string into structural types. Supported
-    # types are Arrays, Hashes and basic value types. It is possible to supply
-    # query strings with parameters of conflicting types, in this case a
-    # ParameterTypeError is raised. Users are encouraged to return a 400 in this
-    # case.
-    def parse_nested_query(qs, d = nil)
-      params = KeySpaceConstrainedParams.new
 
-      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
-        k, v = p.split('=', 2).map { |s| unescape(s) }
+    def self.param_depth_limit=(v)
+      self.default_query_parser = self.default_query_parser.new_depth_limit(v)
+    end
 
-        normalize_params(params, k, v)
-      end
+    def self.key_space_limit
+      default_query_parser.key_space_limit
+    end
 
-      return params.to_params_hash
-    rescue ArgumentError => e
-      raise InvalidParameterError, e.message
+    def self.key_space_limit=(v)
+      self.default_query_parser = self.default_query_parser.new_space_limit(v)
     end
-    module_function :parse_nested_query
 
-    # normalize_params recursively expands parameters into structural types. If
-    # the structural types represented by two different parameter names are in
-    # conflict, a ParameterTypeError is raised.
-    def normalize_params(params, name, v = nil, depth = Utils.param_depth_limit)
-      raise RangeError if depth <= 0
-
-      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
-      k = $1 || ''
-      after = $' || ''
-
-      return if k.empty?
-
-      if after == ""
-        params[k] = v
-      elsif after == "["
-        params[name] = v
-      elsif after == "[]"
-        params[k] ||= []
-        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        params[k] << v
-      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
-        child_key = $1
-        params[k] ||= []
-        raise ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        if params_hash_type?(params[k].last) && !params[k].last.key?(child_key)
-          normalize_params(params[k].last, child_key, v, depth - 1)
-        else
-          params[k] << normalize_params(params.class.new, child_key, v, depth - 1)
-        end
-      else
-        params[k] ||= params.class.new
-        raise ParameterTypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
-        params[k] = normalize_params(params[k], after, v, depth - 1)
+    if defined?(Process::CLOCK_MONOTONIC)
+      def clock_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    else
+      def clock_time
+        Time.now.to_f
       end
+    end
+    module_function :clock_time
 
-      return params
+    def parse_query(qs, d = nil, &unescaper)
+      Rack::Utils.default_query_parser.parse_query(qs, d, &unescaper)
     end
-    module_function :normalize_params
+    module_function :parse_query
 
-    def params_hash_type?(obj)
-      obj.kind_of?(KeySpaceConstrainedParams) || obj.kind_of?(Hash)
+    def parse_nested_query(qs, d = nil)
+      Rack::Utils.default_query_parser.parse_nested_query(qs, d)
     end
-    module_function :params_hash_type?
+    module_function :parse_nested_query
 
     def build_query(params)
       params.map { |k, v|
@@ -236,13 +162,8 @@ module Rack
       '"' => "&quot;",
       "/" => "&#x2F;"
     }
-    if //.respond_to?(:encoding)
-      ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-    else
-      # On 1.8, there is a kcode = 'u' bug that allows for XSS otherwise
-      # TODO doesn't apply to jruby, so a better condition above might be preferable?
-      ESCAPE_HTML_PATTERN = /#{Regexp.union(*ESCAPE_HTML.keys)}/n
-    end
+
+    ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
 
     # Escape ampersands, brackets and quotes to their HTML/XML entities.
     def escape_html(string)
@@ -278,12 +199,28 @@ module Rack
     end
     module_function :select_best_encoding
 
-    def set_cookie_header!(header, key, value)
+    def parse_cookies(env)
+      parse_cookies_header env[HTTP_COOKIE]
+    end
+    module_function :parse_cookies
+
+    def parse_cookies_header(header)
+      # 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.
+      cookies = parse_query(header, ';,') { |s| unescape(s) rescue s }
+      cookies.each_with_object({}) { |(k,v), hash| hash[k] = Array === v ? v.first : v }
+    end
+    module_function :parse_cookies_header
+
+    def add_cookie_to_header(header, key, value)
       case value
       when Hash
-        domain  = "; domain="  + value[:domain]       if value[:domain]
-        path    = "; path="    + value[:path]         if value[:path]
-        max_age = "; max-age=" + value[:max_age].to_s if value[:max_age]
+        domain  = "; domain=#{value[:domain]}"   if value[:domain]
+        path    = "; path=#{value[:path]}"       if value[:path]
+        max_age = "; max-age=#{value[:max_age]}" if value[:max_age]
         # There is an RFC mess in the area of date formatting for Cookies. Not
         # only are there contradicting RFCs and examples within RFC text, but
         # there are also numerous conflicting names of fields and partially
@@ -291,7 +228,7 @@ module Rack
         #
         # These are best described in RFC 2616 3.3.1. This RFC text also
         # specifies that RFC 822 as updated by RFC 1123 is preferred. That is a
-        # fixed length format with space-date delimeted fields.
+        # fixed length format with space-date delimited fields.
         #
         # See also RFC 1123 section 5.2.14.
         #
@@ -315,6 +252,8 @@ module Rack
           case value[:same_site]
           when false, nil
             nil
+          when :none, 'None', :None
+            '; SameSite=None'.freeze
           when :lax, 'Lax', :Lax
             '; SameSite=Lax'.freeze
           when true, :strict, 'Strict', :Strict
@@ -325,31 +264,37 @@ module Rack
         value = value[:value]
       end
       value = [value] unless Array === value
-      cookie = escape(key) + "=" +
-        value.map { |v| escape v }.join("&") +
-        "#{domain}#{path}#{max_age}#{expires}#{secure}#{httponly}#{same_site}"
 
-      case header["Set-Cookie"]
+      cookie = "#{escape(key)}=#{value.map { |v| escape v }.join('&')}#{domain}" \
+        "#{path}#{max_age}#{expires}#{secure}#{httponly}#{same_site}"
+
+      case header
       when nil, ''
-        header["Set-Cookie"] = cookie
+        cookie
       when String
-        header["Set-Cookie"] = [header["Set-Cookie"], cookie].join("\n")
+        [header, cookie].join("\n")
       when Array
-        header["Set-Cookie"] = (header["Set-Cookie"] + [cookie]).join("\n")
+        (header + [cookie]).join("\n")
+      else
+        raise ArgumentError, "Unrecognized cookie header value. Expected String, Array, or nil, got #{header.inspect}"
       end
+    end
+    module_function :add_cookie_to_header
 
+    def set_cookie_header!(header, key, value)
+      header[SET_COOKIE] = add_cookie_to_header(header[SET_COOKIE], key, value)
       nil
     end
     module_function :set_cookie_header!
 
-    def delete_cookie_header!(header, key, value = {})
-      case header["Set-Cookie"]
+    def make_delete_cookie_header(header, key, value)
+      case header
       when nil, ''
         cookies = []
       when String
-        cookies = header["Set-Cookie"].split("\n")
+        cookies = header.split("\n")
       when Array
-        cookies = header["Set-Cookie"]
+        cookies = header
       end
 
       cookies.reject! { |cookie|
@@ -362,29 +307,28 @@ module Rack
         end
       }
 
-      header["Set-Cookie"] = cookies.join("\n")
-
-      set_cookie_header!(header, key,
-                 {:value => '', :path => nil, :domain => nil,
-                   :max_age => '0',
-                   :expires => Time.at(0) }.merge(value))
+      cookies.join("\n")
+    end
+    module_function :make_delete_cookie_header
 
+    def delete_cookie_header!(header, key, value = {})
+      header[SET_COOKIE] = add_remove_cookie_to_header(header[SET_COOKIE], key, value)
       nil
     end
     module_function :delete_cookie_header!
 
-    # Return the bytesize of String; uses String#size under Ruby 1.8 and
-    # String#bytesize under 1.9.
-    if ''.respond_to?(:bytesize)
-      def bytesize(string)
-        string.bytesize
-      end
-    else
-      def bytesize(string)
-        string.size
-      end
+    # Adds a cookie that will *remove* a cookie from the client.  Hence the
+    # strange method name.
+    def add_remove_cookie_to_header(header, key, value = {})
+      new_header = make_delete_cookie_header(header, key, value)
+
+      add_cookie_to_header(new_header, key,
+                 {:value => '', :path => nil, :domain => nil,
+                   :max_age => '0',
+                   :expires => Time.at(0) }.merge(value))
+
     end
-    module_function :bytesize
+    module_function :add_remove_cookie_to_header
 
     def rfc2822(time)
       time.rfc2822
@@ -411,8 +355,13 @@ module Rack
     # Returns nil if the header is missing or syntactically invalid.
     # Returns an empty array if none of the ranges are satisfiable.
     def byte_ranges(env, size)
+      warn "`byte_ranges` is deprecated, please use `get_byte_ranges`" if $VERBOSE
+      get_byte_ranges env['HTTP_RANGE'], size
+    end
+    module_function :byte_ranges
+
+    def get_byte_ranges(http_range, size)
       # See <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35>
-      http_range = env['HTTP_RANGE']
       return nil unless http_range && http_range =~ /bytes=([^;]+)/
       ranges = []
       $1.split(/,\s*/).each do |range_spec|
@@ -438,7 +387,7 @@ module Rack
       end
       ranges
     end
-    module_function :byte_ranges
+    module_function :get_byte_ranges
 
     # Constant time string comparison.
     #
@@ -447,7 +396,7 @@ module Rack
     # on variable length plaintext strings because it could leak length info
     # via timing attacks.
     def secure_compare(a, b)
-      return false unless bytesize(a) == bytesize(b)
+      return false unless a.bytesize == b.bytesize
 
       l = a.unpack("C*")
 
@@ -496,6 +445,12 @@ module Rack
         hash.each { |k, v| self[k] = v }
       end
 
+      # on dup/clone, we need to duplicate @names hash
+      def initialize_copy(other)
+        super
+        @names = other.names.dup
+      end
+
       def each
         super do |k, v|
           yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
@@ -513,21 +468,20 @@ module Rack
       end
 
       def []=(k, v)
-        canonical = k.downcase
+        canonical = k.downcase.freeze
         delete k if @names[canonical] && @names[canonical] != k # .delete is expensive, don't invoke it unless necessary
-        @names[k] = @names[canonical] = k
+        @names[canonical] = k
         super k, v
       end
 
       def delete(k)
         canonical = k.downcase
         result = super @names.delete(canonical)
-        @names.delete_if { |name,| name.downcase == canonical }
         result
       end
 
       def include?(k)
-        @names.include?(k) || @names.include?(k.downcase)
+        super || @names.include?(k.downcase)
       end
 
       alias_method :has_key?, :include?
@@ -549,45 +503,11 @@ module Rack
         other.each { |k, v| self[k] = v }
         self
       end
-    end
-
-    class KeySpaceConstrainedParams
-      def initialize(limit = Utils.key_space_limit)
-        @limit  = limit
-        @size   = 0
-        @params = {}
-      end
-
-      def [](key)
-        @params[key]
-      end
 
-      def []=(key, value)
-        @size += key.size if key && !@params.key?(key)
-        raise RangeError, 'exceeded available parameter key space' if @size > @limit
-        @params[key] = value
-      end
-
-      def key?(key)
-        @params.key?(key)
-      end
-
-      def to_params_hash
-        hash = @params
-        hash.keys.each do |key|
-          value = hash[key]
-          if value.kind_of?(self.class)
-            if value.object_id == self.object_id
-              hash[key] = hash
-            else
-              hash[key] = value.to_params_hash
-            end
-          elsif value.kind_of?(Array)
-            value.map! {|x| x.kind_of?(self.class) ? x.to_params_hash : x}
-          end
+      protected
+        def names
+          @names
         end
-        hash
-      end
     end
 
     # Every standard HTTP code mapped to the appropriate message.
@@ -635,6 +555,7 @@ module Rack
       415 => 'Unsupported Media Type',
       416 => 'Range Not Satisfiable',
       417 => 'Expectation Failed',
+      421 => 'Misdirected Request',
       422 => 'Unprocessable Entity',
       423 => 'Locked',
       424 => 'Failed Dependency',
@@ -642,6 +563,7 @@ module Rack
       428 => 'Precondition Required',
       429 => 'Too Many Requests',
       431 => 'Request Header Fields Too Large',
+      451 => 'Unavailable for Legal Reasons',
       500 => 'Internal Server Error',
       501 => 'Not Implemented',
       502 => 'Bad Gateway',
@@ -656,7 +578,7 @@ module Rack
     }
 
     # Responses with HTTP status codes that should not have an entity body
-    STATUS_WITH_NO_ENTITY_BODY = Set.new((100..199).to_a << 204 << 205 << 304)
+    STATUS_WITH_NO_ENTITY_BODY = Set.new((100..199).to_a << 204 << 304)
 
     SYMBOL_TO_STATUS_CODE = Hash[*HTTP_STATUS_CODES.map { |code, message|
       [message.downcase.gsub(/\s|-|'/, '_').to_sym, code]
@@ -671,8 +593,6 @@ module Rack
     end
     module_function :status_code
 
-    Multipart = Rack::Multipart
-
     PATH_SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
 
     def clean_path_info(path_info)
@@ -691,5 +611,12 @@ module Rack
     end
     module_function :clean_path_info
 
+    NULL_BYTE = "\0".freeze
+
+    def valid_path?(path)
+      path.valid_encoding? && !path.include?(NULL_BYTE)
+    end
+    module_function :valid_path?
+
   end
 end

data/lib/rack.rb

@@ -7,7 +7,7 @@
 # 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.
+# so it should be enough just to <tt>require 'rack'</tt> in your code.
 
 module Rack
   # The Rack protocol version number implemented.
@@ -18,27 +18,80 @@ module Rack
     VERSION.join(".")
   end
 
+  RELEASE = "2.0.9"
+
   # Return the Rack release as a dotted string.
   def self.release
-    "1.6.13"
+    RELEASE
   end
-  PATH_INFO      = 'PATH_INFO'.freeze
-  REQUEST_METHOD = 'REQUEST_METHOD'.freeze
-  SCRIPT_NAME    = 'SCRIPT_NAME'.freeze
-  QUERY_STRING   = 'QUERY_STRING'.freeze
-  CACHE_CONTROL  = 'Cache-Control'.freeze
-  CONTENT_LENGTH = 'Content-Length'.freeze
-  CONTENT_TYPE   = 'Content-Type'.freeze
 
-  GET  = 'GET'.freeze
-  HEAD = 'HEAD'.freeze
+  HTTP_HOST         = 'HTTP_HOST'.freeze
+  HTTP_VERSION      = 'HTTP_VERSION'.freeze
+  HTTPS             = 'HTTPS'.freeze
+  PATH_INFO         = 'PATH_INFO'.freeze
+  REQUEST_METHOD    = 'REQUEST_METHOD'.freeze
+  REQUEST_PATH      = 'REQUEST_PATH'.freeze
+  SCRIPT_NAME       = 'SCRIPT_NAME'.freeze
+  QUERY_STRING      = 'QUERY_STRING'.freeze
+  SERVER_PROTOCOL   = 'SERVER_PROTOCOL'.freeze
+  SERVER_NAME       = 'SERVER_NAME'.freeze
+  SERVER_ADDR       = 'SERVER_ADDR'.freeze
+  SERVER_PORT       = 'SERVER_PORT'.freeze
+  CACHE_CONTROL     = 'Cache-Control'.freeze
+  CONTENT_LENGTH    = 'Content-Length'.freeze
+  CONTENT_TYPE      = 'Content-Type'.freeze
+  SET_COOKIE        = 'Set-Cookie'.freeze
+  TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+  HTTP_COOKIE       = 'HTTP_COOKIE'.freeze
+  ETAG              = 'ETag'.freeze
+
+  # HTTP method verbs
+  GET     = 'GET'.freeze
+  POST    = 'POST'.freeze
+  PUT     = 'PUT'.freeze
+  PATCH   = 'PATCH'.freeze
+  DELETE  = 'DELETE'.freeze
+  HEAD    = 'HEAD'.freeze
+  OPTIONS = 'OPTIONS'.freeze
+  LINK    = 'LINK'.freeze
+  UNLINK  = 'UNLINK'.freeze
+  TRACE   = 'TRACE'.freeze
+
+  # Rack environment variables
+  RACK_VERSION                        = 'rack.version'.freeze
+  RACK_TEMPFILES                      = 'rack.tempfiles'.freeze
+  RACK_ERRORS                         = 'rack.errors'.freeze
+  RACK_LOGGER                         = 'rack.logger'.freeze
+  RACK_INPUT                          = 'rack.input'.freeze
+  RACK_SESSION                        = 'rack.session'.freeze
+  RACK_SESSION_OPTIONS                = 'rack.session.options'.freeze
+  RACK_SHOWSTATUS_DETAIL              = 'rack.showstatus.detail'.freeze
+  RACK_MULTITHREAD                    = 'rack.multithread'.freeze
+  RACK_MULTIPROCESS                   = 'rack.multiprocess'.freeze
+  RACK_RUNONCE                        = 'rack.run_once'.freeze
+  RACK_URL_SCHEME                     = 'rack.url_scheme'.freeze
+  RACK_HIJACK                         = 'rack.hijack'.freeze
+  RACK_IS_HIJACK                      = 'rack.hijack?'.freeze
+  RACK_HIJACK_IO                      = 'rack.hijack_io'.freeze
+  RACK_RECURSIVE_INCLUDE              = 'rack.recursive.include'.freeze
+  RACK_MULTIPART_BUFFER_SIZE          = 'rack.multipart.buffer_size'.freeze
+  RACK_MULTIPART_TEMPFILE_FACTORY     = 'rack.multipart.tempfile_factory'.freeze
+  RACK_REQUEST_FORM_INPUT             = 'rack.request.form_input'.freeze
+  RACK_REQUEST_FORM_HASH              = 'rack.request.form_hash'.freeze
+  RACK_REQUEST_FORM_VARS              = 'rack.request.form_vars'.freeze
+  RACK_REQUEST_COOKIE_HASH            = 'rack.request.cookie_hash'.freeze
+  RACK_REQUEST_COOKIE_STRING          = 'rack.request.cookie_string'.freeze
+  RACK_REQUEST_QUERY_HASH             = 'rack.request.query_hash'.freeze
+  RACK_REQUEST_QUERY_STRING           = 'rack.request.query_string'.freeze
+  RACK_METHODOVERRIDE_ORIGINAL_METHOD = 'rack.methodoverride.original_method'.freeze
+  RACK_SESSION_UNPACKED_COOKIE_DATA   = 'rack.session.unpacked_cookie_data'.freeze
 
   autoload :Builder, "rack/builder"
   autoload :BodyProxy, "rack/body_proxy"
   autoload :Cascade, "rack/cascade"
   autoload :Chunked, "rack/chunked"
-  autoload :CommonLogger, "rack/commonlogger"
-  autoload :ConditionalGet, "rack/conditionalget"
+  autoload :CommonLogger, "rack/common_logger"
+  autoload :ConditionalGet, "rack/conditional_get"
   autoload :Config, "rack/config"
   autoload :ContentLength, "rack/content_length"
   autoload :ContentType, "rack/content_type"
@@ -52,16 +105,16 @@ module Rack
   autoload :Lint, "rack/lint"
   autoload :Lock, "rack/lock"
   autoload :Logger, "rack/logger"
-  autoload :MethodOverride, "rack/methodoverride"
+  autoload :MethodOverride, "rack/method_override"
   autoload :Mime, "rack/mime"
-  autoload :NullLogger, "rack/nulllogger"
+  autoload :NullLogger, "rack/null_logger"
   autoload :Recursive, "rack/recursive"
   autoload :Reloader, "rack/reloader"
   autoload :Runtime, "rack/runtime"
   autoload :Sendfile, "rack/sendfile"
   autoload :Server, "rack/server"
-  autoload :ShowExceptions, "rack/showexceptions"
-  autoload :ShowStatus, "rack/showstatus"
+  autoload :ShowExceptions, "rack/show_exceptions"
+  autoload :ShowStatus, "rack/show_status"
   autoload :Static, "rack/static"
   autoload :TempfileReaper, "rack/tempfile_reaper"
   autoload :URLMap, "rack/urlmap"
@@ -91,8 +144,4 @@ module Rack
     autoload :Pool, "rack/session/pool"
     autoload :Memcache, "rack/session/memcache"
   end
-
-  module Utils
-    autoload :OkJson, "rack/utils/okjson"
-  end
 end