rack 1.6.12 → 2.0.3

data/lib/rack/lobster.rb

@@ -63,7 +63,7 @@ end
 
 if $0 == __FILE__
   require 'rack'
-  require 'rack/showexceptions'
+  require 'rack/show_exceptions'
   Rack::Server.start(
     :app => Rack::ShowExceptions.new(Rack::Lint.new(Rack::Lobster.new)), :Port => 9292
   )

data/lib/rack/lock.rb

@@ -5,22 +5,18 @@ module Rack
   # Rack::Lock locks every request inside a mutex, so that every request
   # will effectively be executed synchronously.
   class Lock
-    FLAG = 'rack.multithread'.freeze
-
     def initialize(app, mutex = Mutex.new)
       @app, @mutex = app, mutex
     end
 
     def call(env)
-      old, env[FLAG] = env[FLAG], false
       @mutex.lock
-      response = @app.call(env)
-      body = BodyProxy.new(response[2]) { @mutex.unlock }
-      response[2] = body
-      response
-    ensure
-      @mutex.unlock unless body
-      env[FLAG] = old
+      begin
+        response = @app.call(env.merge(RACK_MULTITHREAD => false))
+        returned = response << BodyProxy.new(response.pop) { @mutex.unlock }
+      ensure
+        @mutex.unlock unless returned
+      end
     end
   end
 end

data/lib/rack/logger.rb

@@ -8,10 +8,10 @@ module Rack
     end
 
     def call(env)
-      logger = ::Logger.new(env['rack.errors'])
+      logger = ::Logger.new(env[RACK_ERRORS])
       logger.level = @level
 
-      env['rack.logger'] = logger
+      env[RACK_LOGGER] = logger
       @app.call(env)
     end
   end

data/lib/rack/media_type.rb

@@ -0,0 +1,38 @@
+module Rack
+  # Rack::MediaType parse media type and parameters out of content_type string
+
+  class MediaType
+    SPLIT_PATTERN = %r{\s*[;,]\s*}
+
+    class << self
+      # 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 type(content_type)
+        return nil unless content_type
+        content_type.split(SPLIT_PATTERN, 2).first.downcase
+      end
+
+      # The media type parameters provided in CONTENT_TYPE as a Hash, or
+      # an empty Hash if no CONTENT_TYPE or media-type parameters were
+      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
+      # this method responds with the following Hash:
+      #   { 'charset' => 'utf-8' }
+      def params(content_type)
+        return {} if content_type.nil?
+        Hash[*content_type.split(SPLIT_PATTERN)[1..-1].
+          collect { |s| s.split('=', 2) }.
+          map { |k,v| [k.downcase, strip_doublequotes(v)] }.flatten]
+      end
+
+      private
+
+        def strip_doublequotes(str)
+          (str[0] == ?" && str[-1] == ?") ? str[1..-2] : str
+        end
+    end
+  end
+end

data/lib/rack/{methodoverride.rb → method_override.rb}

@@ -1,10 +1,10 @@
 module Rack
   class MethodOverride
-    HTTP_METHODS = %w(GET HEAD PUT POST DELETE OPTIONS PATCH LINK UNLINK)
+    HTTP_METHODS = %w[GET HEAD PUT POST DELETE OPTIONS PATCH LINK UNLINK]
 
     METHOD_OVERRIDE_PARAM_KEY = "_method".freeze
     HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE".freeze
-    ALLOWED_METHODS = ["POST"]
+    ALLOWED_METHODS = %w[POST]
 
     def initialize(app)
       @app = app
@@ -14,7 +14,7 @@ module Rack
       if allowed_methods.include?(env[REQUEST_METHOD])
         method = method_override(env)
         if HTTP_METHODS.include?(method)
-          env["rack.methodoverride.original_method"] = env[REQUEST_METHOD]
+          env[RACK_METHODOVERRIDE_ORIGINAL_METHOD] = env[REQUEST_METHOD]
           env[REQUEST_METHOD] = method
         end
       end
@@ -26,11 +26,7 @@ module Rack
       req = Request.new(env)
       method = method_override_param(req) ||
         env[HTTP_METHOD_OVERRIDE_HEADER]
-      begin
-        method.to_s.upcase
-      rescue ArgumentError
-        env["rack.errors"].puts "Invalid string for method"
-      end
+      method.to_s.upcase
     end
 
     private
@@ -42,9 +38,9 @@ module Rack
     def method_override_param(req)
       req.POST[METHOD_OVERRIDE_PARAM_KEY]
     rescue Utils::InvalidParameterError, Utils::ParameterTypeError
-      req.env["rack.errors"].puts "Invalid or incomplete POST params"
+      req.get_header(RACK_ERRORS).puts "Invalid or incomplete POST params"
     rescue EOFError
-      req.env["rack.errors"].puts "Bad request content body"
+      req.get_header(RACK_ERRORS).puts "Bad request content body"
     end
   end
 end

data/lib/rack/mime.rb

@@ -45,11 +45,6 @@ module Rack
     #
     # N.B. On Ubuntu the mime.types file does not include the leading period, so
     # users may need to modify the data before merging into the hash.
-    #
-    # To add the list mongrel provides, use:
-    #
-    #     require 'mongrel/handlers'
-    #     Rack::Mime::MIME_TYPES.merge!(Mongrel::DirHandler::MIME_TYPES)
 
     MIME_TYPES = {
       ".123"       => "application/vnd.lotus-1-2-3",
@@ -154,8 +149,11 @@ module Rack
       ".dmg"       => "application/octet-stream",
       ".dna"       => "application/vnd.dna",
       ".doc"       => "application/msword",
+      ".docm"      => "application/vnd.ms-word.document.macroEnabled.12",
       ".docx"      => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
       ".dot"       => "application/msword",
+      ".dotm"      => "application/vnd.ms-word.template.macroEnabled.12",
+      ".dotx"      => "application/vnd.openxmlformats-officedocument.wordprocessingml.template",
       ".dp"        => "application/vnd.osgi.dp",
       ".dpg"       => "application/vnd.dpgraph",
       ".dsc"       => "text/prs.lines.tag",
@@ -444,10 +442,19 @@ module Rack
       ".pnm"       => "image/x-portable-anymap",
       ".pntg"      => "image/x-macpaint",
       ".portpkg"   => "application/vnd.macports.portpkg",
+      ".pot"       => "application/vnd.ms-powerpoint",
+      ".potm"      => "application/vnd.ms-powerpoint.template.macroEnabled.12",
+      ".potx"      => "application/vnd.openxmlformats-officedocument.presentationml.template",
+      ".ppa"       => "application/vnd.ms-powerpoint",
+      ".ppam"      => "application/vnd.ms-powerpoint.addin.macroEnabled.12",
       ".ppd"       => "application/vnd.cups-ppd",
       ".ppm"       => "image/x-portable-pixmap",
       ".pps"       => "application/vnd.ms-powerpoint",
+      ".ppsm"      => "application/vnd.ms-powerpoint.slideshow.macroEnabled.12",
+      ".ppsx"      => "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
       ".ppt"       => "application/vnd.ms-powerpoint",
+      ".pptm"      => "application/vnd.ms-powerpoint.presentation.macroEnabled.12",
+      ".pptx"      => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
       ".prc"       => "application/vnd.palm",
       ".pre"       => "application/vnd.lotus-freelance",
       ".prf"       => "application/pics-rules",
@@ -638,8 +645,14 @@ module Rack
       ".xfdl"      => "application/vnd.xfdl",
       ".xhtml"     => "application/xhtml+xml",
       ".xif"       => "image/vnd.xiff",
+      ".xla"       => "application/vnd.ms-excel",
+      ".xlam"      => "application/vnd.ms-excel.addin.macroEnabled.12",
       ".xls"       => "application/vnd.ms-excel",
+      ".xlsb"      => "application/vnd.ms-excel.sheet.binary.macroEnabled.12",
       ".xlsx"      => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".xlsm"      => "application/vnd.ms-excel.sheet.macroEnabled.12",
+      ".xlt"       => "application/vnd.ms-excel",
+      ".xltx"      => "application/vnd.openxmlformats-officedocument.spreadsheetml.template",
       ".xml"       => "application/xml",
       ".xo"        => "application/vnd.olpc-sugar",
       ".xop"       => "application/xop+xml",

data/lib/rack/mock.rb

@@ -41,27 +41,27 @@ module Rack
     end
 
     DEFAULT_ENV = {
-      "rack.version" => Rack::VERSION,
-      "rack.input" => StringIO.new,
-      "rack.errors" => StringIO.new,
-      "rack.multithread" => true,
-      "rack.multiprocess" => true,
-      "rack.run_once" => false,
-    }
+      RACK_VERSION      => Rack::VERSION,
+      RACK_INPUT        => StringIO.new,
+      RACK_ERRORS       => StringIO.new,
+      RACK_MULTITHREAD  => true,
+      RACK_MULTIPROCESS => true,
+      RACK_RUNONCE      => false,
+    }.freeze
 
     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 patch(uri, opts={})   request("PATCH", uri, opts)   end
-    def delete(uri, opts={})  request("DELETE", uri, opts)  end
-    def head(uri, opts={})    request("HEAD", uri, opts)    end
-    def options(uri, opts={}) request("OPTIONS", uri, opts) 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 patch(uri, opts={})   request(PATCH, uri, opts)   end
+    def delete(uri, opts={})  request(DELETE, uri, opts)  end
+    def head(uri, opts={})    request(HEAD, uri, opts)    end
+    def options(uri, opts={}) request(OPTIONS, uri, opts) end
 
-    def request(method="GET", uri="", opts={})
+    def request(method=GET, uri="", opts={})
       env = self.class.env_for(uri, opts.merge(:method => method))
 
       if opts[:lint]
@@ -70,17 +70,17 @@ module Rack
         app = @app
       end
 
-      errors = env["rack.errors"]
+      errors = env[RACK_ERRORS]
       status, headers, body  = app.call(env)
       MockResponse.new(status, headers, body, errors)
     ensure
       body.close if body.respond_to?(:close)
     end
 
-    # For historical reasons, we're pinning to RFC 2396. It's easier for users
-    # and we get support from ruby 1.8 to 2.2 using this method.
+    # For historical reasons, we're pinning to RFC 2396.
+    # URI::Parser = URI::RFC2396_Parser
     def self.parse_uri_rfc2396(uri)
-      @parser ||= defined?(URI::RFC2396_Parser) ? URI::RFC2396_Parser.new : URI
+      @parser ||= URI::Parser.new
       @parser.parse(uri)
     end
 
@@ -91,28 +91,34 @@ module Rack
 
       env = DEFAULT_ENV.dup
 
-      env_with_encoding(env, opts, uri)
+      env[REQUEST_METHOD]  = (opts[:method] ? opts[:method].to_s.upcase : GET).b
+      env[SERVER_NAME]     = (uri.host || "example.org").b
+      env[SERVER_PORT]     = (uri.port ? uri.port.to_s : "80").b
+      env[QUERY_STRING]    = (uri.query.to_s).b
+      env[PATH_INFO]       = ((!uri.path || uri.path.empty?) ? "/" : uri.path).b
+      env[RACK_URL_SCHEME] = (uri.scheme || "http").b
+      env[HTTPS]           = (env[RACK_URL_SCHEME] == "https" ? "on" : "off").b
 
       env[SCRIPT_NAME] = opts[:script_name] || ""
 
       if opts[:fatal]
-        env["rack.errors"] = FatalWarner.new
+        env[RACK_ERRORS] = FatalWarner.new
       else
-        env["rack.errors"] = StringIO.new
+        env[RACK_ERRORS] = StringIO.new
       end
 
       if params = opts[:params]
-        if env[REQUEST_METHOD] == "GET"
+        if env[REQUEST_METHOD] == GET
           params = Utils.parse_nested_query(params) if params.is_a?(String)
           params.update(Utils.parse_nested_query(env[QUERY_STRING]))
           env[QUERY_STRING] = Utils.build_nested_query(params)
         elsif !opts.has_key?(:input)
           opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
           if params.is_a?(Hash)
-            if data = Utils::Multipart.build_multipart(params)
+            if data = Rack::Multipart.build_multipart(params)
               opts[:input] = data
               opts["CONTENT_LENGTH"] ||= data.length.to_s
-              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Utils::Multipart::MULTIPART_BOUNDARY}"
+              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Rack::Multipart::MULTIPART_BOUNDARY}"
             else
               opts[:input] = Utils.build_nested_query(params)
             end
@@ -122,8 +128,7 @@ module Rack
         end
       end
 
-      empty_str = ""
-      empty_str.force_encoding("ASCII-8BIT") if empty_str.respond_to? :force_encoding
+      empty_str = String.new.force_encoding(Encoding::ASCII_8BIT)
       opts[:input] ||= empty_str
       if String === opts[:input]
         rack_input = StringIO.new(opts[:input])
@@ -131,10 +136,10 @@ module Rack
         rack_input = opts[:input]
       end
 
-      rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
-      env['rack.input'] = rack_input
+      rack_input.set_encoding(Encoding::BINARY)
+      env[RACK_INPUT] = rack_input
 
-      env["CONTENT_LENGTH"] ||= env["rack.input"].length.to_s
+      env["CONTENT_LENGTH"] ||= env[RACK_INPUT].length.to_s
 
       opts.each { |field, value|
         env[field] = value  if String === field
@@ -142,28 +147,6 @@ module Rack
 
       env
     end
-
-    if "<3".respond_to? :b
-      def self.env_with_encoding(env, opts, uri)
-        env[REQUEST_METHOD] = (opts[:method] ? opts[:method].to_s.upcase : "GET").b
-        env["SERVER_NAME"] = (uri.host || "example.org").b
-        env["SERVER_PORT"] = (uri.port ? uri.port.to_s : "80").b
-        env[QUERY_STRING] = (uri.query.to_s).b
-        env[PATH_INFO] = ((!uri.path || uri.path.empty?) ? "/" : uri.path).b
-        env["rack.url_scheme"] = (uri.scheme || "http").b
-        env["HTTPS"] = (env["rack.url_scheme"] == "https" ? "on" : "off").b
-      end
-    else
-      def self.env_with_encoding(env, opts, uri)
-        env[REQUEST_METHOD] = opts[:method] ? opts[:method].to_s.upcase : "GET"
-        env["SERVER_NAME"] = uri.host || "example.org"
-        env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
-        env[QUERY_STRING] = uri.query.to_s
-        env[PATH_INFO] = (!uri.path || uri.path.empty?) ? "/" : uri.path
-        env["rack.url_scheme"] = uri.scheme || "http"
-        env["HTTPS"] = env["rack.url_scheme"] == "https" ? "on" : "off"
-      end
-    end
   end
 
   # Rack::MockResponse provides useful helpers for testing your apps.
@@ -180,7 +163,6 @@ module Rack
     def initialize(status, headers, body, errors=StringIO.new(""))
       @original_headers = headers
       @errors           = errors.string if errors.respond_to?(:string)
-      @body_string      = nil
 
       super(body, status, headers)
     end
@@ -208,7 +190,7 @@ module Rack
     end
 
     def empty?
-      [201, 204, 205, 304].include? status
+      [201, 204, 304].include? status
     end
   end
 end

data/lib/rack/multipart.rb

@@ -1,10 +1,11 @@
+require 'rack/multipart/parser'
+
 module Rack
   # A multipart form data parser, adapted from IOWA.
   #
   # Usually, Rack::Request#POST takes care of calling this.
   module Multipart
     autoload :UploadedFile, 'rack/multipart/uploaded_file'
-    autoload :Parser, 'rack/multipart/parser'
     autoload :Generator, 'rack/multipart/generator'
 
     EOL = "\r\n"
@@ -12,17 +13,45 @@ module Rack
     MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|ni
     TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/
     CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i
-    DISPPARM = /;\s*(#{TOKEN})=("(?:\\"|[^"])*"|#{TOKEN})/
-    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
+    VALUE = /"(?:\\"|[^"])*"|#{TOKEN}/
     BROKEN_QUOTED = /^#{CONDISP}.*;\sfilename="(.*?)"(?:\s*$|\s*;\s*#{TOKEN}=)/i
     BROKEN_UNQUOTED = /^#{CONDISP}.*;\sfilename=(#{TOKEN})/i
     MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{EOL}/ni
-    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name="?([^\";]*)"?/ni
+    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name=(#{VALUE})/ni
     MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{EOL}]*)/ni
+    # Updated definitions from RFC 2231
+    ATTRIBUTE_CHAR = %r{[^ \t\v\n\r)(><@,;:\\"/\[\]?='*%]}
+    ATTRIBUTE = /#{ATTRIBUTE_CHAR}+/
+    SECTION = /\*[0-9]+/
+    REGULAR_PARAMETER_NAME = /#{ATTRIBUTE}#{SECTION}?/
+    REGULAR_PARAMETER = /(#{REGULAR_PARAMETER_NAME})=(#{VALUE})/
+    EXTENDED_OTHER_NAME = /#{ATTRIBUTE}\*[1-9][0-9]*\*/
+    EXTENDED_OTHER_VALUE = /%[0-9a-fA-F]{2}|#{ATTRIBUTE_CHAR}/
+    EXTENDED_OTHER_PARAMETER = /(#{EXTENDED_OTHER_NAME})=(#{EXTENDED_OTHER_VALUE}*)/
+    EXTENDED_INITIAL_NAME = /#{ATTRIBUTE}(?:\*0)?\*/
+    EXTENDED_INITIAL_VALUE = /[a-zA-Z0-9\-]*'[a-zA-Z0-9\-]*'#{EXTENDED_OTHER_VALUE}*/
+    EXTENDED_INITIAL_PARAMETER = /(#{EXTENDED_INITIAL_NAME})=(#{EXTENDED_INITIAL_VALUE})/
+    EXTENDED_PARAMETER = /#{EXTENDED_INITIAL_PARAMETER}|#{EXTENDED_OTHER_PARAMETER}/
+    DISPPARM = /;\s*(?:#{REGULAR_PARAMETER}|#{EXTENDED_PARAMETER})\s*/
+    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
 
     class << self
-      def parse_multipart(env)
-        Parser.create(env).parse
+      def parse_multipart(env, params = Rack::Utils.default_query_parser)
+        extract_multipart Rack::Request.new(env), params
+      end
+
+      def extract_multipart(req, params = Rack::Utils.default_query_parser)
+        io = req.get_header(RACK_INPUT)
+        io.rewind
+        content_length = req.content_length
+        content_length = content_length.to_i if content_length
+
+        tempfile = req.get_header(RACK_MULTIPART_TEMPFILE_FACTORY) || Parser::TEMPFILE_FACTORY
+        bufsize = req.get_header(RACK_MULTIPART_BUFFER_SIZE) || Parser::BUFSIZE
+
+        info = Parser.parse io, content_length, req.get_header('CONTENT_TYPE'), tempfile, bufsize, params
+        req.set_header(RACK_TEMPFILES, info.tmp_files)
+        info.params
       end
 
       def build_multipart(params, first = true)

data/lib/rack/multipart/generator.rb

@@ -11,18 +11,18 @@ module Rack
 
       def dump
         return nil if @first && !multipart?
-        return flattened_params if !@first
+        return flattened_params unless @first
 
         flattened_params.map do |name, file|
           if file.respond_to?(:original_filename)
-            ::File.open(file.path, "rb") do |f|
-              f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+            ::File.open(file.path, 'rb') do |f|
+              f.set_encoding(Encoding::BINARY)
               content_for_tempfile(f, file, name)
             end
           else
             content_for_other(file, name)
           end
-        end.join + "--#{MULTIPART_BOUNDARY}--\r"
+        end.join << "--#{MULTIPART_BOUNDARY}--\r"
       end
 
       private
@@ -90,4 +90,4 @@ EOF
       end
     end
   end
-end
+end