rack 1.6.13 → 2.0.1

data/lib/rack/handler/scgi.rb

@@ -35,24 +35,24 @@ module Rack
         env = Hash[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[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] = ""
 
-        rack_input = StringIO.new(input_body)
-        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+        rack_input = StringIO.new(input_body, encoding: Encoding::BINARY)
 
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => false,
+        env.update(
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => true,
+          RACK_MULTIPROCESS => true,
+          RACK_RUNONCE      => false,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
+        )
 
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-                   })
         status, headers, body = app.call(env)
         begin
           socket.write("Status: #{status}\r\n")

data/lib/rack/handler/thin.rb

@@ -1,4 +1,7 @@
 require "thin"
+require "thin/server"
+require "thin/logging"
+require "thin/backends/tcp_server"
 require "rack/content_length"
 require "rack/chunked"
 

data/lib/rack/handler/webrick.rb

@@ -3,7 +3,7 @@ require 'stringio'
 require 'rack/content_length'
 
 # This monkey patch allows for applications to perform their own chunking
-# through WEBrick::HTTPResponse iff rack is set to true.
+# through WEBrick::HTTPResponse if rack is set to true.
 class WEBrick::HTTPResponse
   attr_accessor :rack
 
@@ -24,7 +24,7 @@ module Rack
     class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
       def self.run(app, options={})
         environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
+        default_host = environment == 'development' ? 'localhost' : nil
 
         options[:BindAddress] = options.delete(:Host) || default_host
         options[:Port] ||= 8080
@@ -60,36 +60,34 @@ module Rack
         env.delete_if { |k, v| v.nil? }
 
         rack_input = StringIO.new(req.body.to_s)
-        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => $stderr,
-
-                     "rack.multithread" => true,
-                     "rack.multiprocess" => false,
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http",
-
-                     "rack.hijack?" => true,
-                     "rack.hijack" => lambda { raise NotImplementedError, "only partial hijack is supported."},
-                     "rack.hijack_io" => nil,
-                   })
-
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        rack_input.set_encoding(Encoding::BINARY)
+
+        env.update(
+          RACK_VERSION      => Rack::VERSION,
+          RACK_INPUT        => rack_input,
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => true,
+          RACK_MULTIPROCESS => false,
+          RACK_RUNONCE      => false,
+          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http",
+          RACK_IS_HIJACK    => true,
+          RACK_HIJACK       => lambda { raise NotImplementedError, "only partial hijack is supported."},
+          RACK_HIJACK_IO    => nil
+        )
+
+        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
         env[QUERY_STRING] ||= ""
         unless env[PATH_INFO] == ""
-          path, n = req.request_uri.path, env["SCRIPT_NAME"].length
+          path, n = req.request_uri.path, env[SCRIPT_NAME].length
           env[PATH_INFO] = path[n, path.length-n]
         end
-        env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env[PATH_INFO]].join
+        env[REQUEST_PATH] ||= [env[SCRIPT_NAME], env[PATH_INFO]].join
 
         status, headers, body = @app.call(env)
         begin
           res.status = status.to_i
           headers.each { |k, vs|
-            next if k.downcase == "rack.hijack"
+            next if k.downcase == RACK_HIJACK
 
             if k.downcase == "set-cookie"
               res.cookies.concat vs.split("\n")
@@ -100,7 +98,7 @@ module Rack
             end
           }
 
-          io_lambda = headers["rack.hijack"]
+          io_lambda = headers[RACK_HIJACK]
           if io_lambda
             rd, wr = IO.pipe
             res.body = rd

data/lib/rack/handler.rb

@@ -19,25 +19,13 @@ module Rack
       if klass = @handlers[server]
         klass.split("::").inject(Object) { |o, x| o.const_get(x) }
       else
-        _const_get(server, false)
+        const_get(server, false)
       end
 
     rescue NameError => name_error
       raise load_error || name_error
     end
 
-    begin
-      ::Object.const_get("Object", false)
-      def self._const_get(str, inherit = true)
-        const_get(str, inherit)
-      end
-    rescue
-      def self._const_get(str, inherit = true)
-        const_get(str)
-      end
-    end
-
-
     # Select first available Rack handler given an `Array` of server names.
     # Raises `LoadError` if no handler was found.
     #
@@ -55,20 +43,16 @@ module Rack
       raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
     end
 
-    def self.default(options = {})
+    def self.default
       # Guess.
       if ENV.include?("PHP_FCGI_CHILDREN")
-        # We already speak FastCGI
-        options.delete :File
-        options.delete :Port
-
         Rack::Handler::FastCGI
       elsif ENV.include?(REQUEST_METHOD)
         Rack::Handler::CGI
       elsif ENV.include?("RACK_HANDLER")
         self.get(ENV["RACK_HANDLER"])
       else
-        pick ['thin', 'puma', 'webrick']
+        pick ['puma', 'thin', 'webrick']
       end
     end
 
@@ -100,9 +84,6 @@ module Rack
 
     autoload :CGI, "rack/handler/cgi"
     autoload :FastCGI, "rack/handler/fastcgi"
-    autoload :Mongrel, "rack/handler/mongrel"
-    autoload :EventedMongrel, "rack/handler/evented_mongrel"
-    autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel"
     autoload :WEBrick, "rack/handler/webrick"
     autoload :LSWS, "rack/handler/lsws"
     autoload :SCGI, "rack/handler/scgi"
@@ -110,9 +91,6 @@ module Rack
 
     register 'cgi', 'Rack::Handler::CGI'
     register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'mongrel', 'Rack::Handler::Mongrel'
-    register 'emongrel', 'Rack::Handler::EventedMongrel'
-    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
     register 'webrick', 'Rack::Handler::WEBrick'
     register 'lsws', 'Rack::Handler::LSWS'
     register 'scgi', 'Rack::Handler::SCGI'

data/lib/rack/head.rb

@@ -1,27 +1,25 @@
 require 'rack/body_proxy'
 
 module Rack
-
-class Head
   # Rack::Head returns an empty body for all HEAD requests. It leaves
   # all other requests unchanged.
-  def initialize(app)
-    @app = app
-  end
+  class Head
+    def initialize(app)
+      @app = app
+    end
 
-  def call(env)
-    status, headers, body = @app.call(env)
+    def call(env)
+      status, headers, body = @app.call(env)
 
-    if env[REQUEST_METHOD] == HEAD
-      [
-        status, headers, Rack::BodyProxy.new([]) do
-          body.close if body.respond_to? :close
-        end
-      ]
-    else
-      [status, headers, body]
+      if env[REQUEST_METHOD] == HEAD
+        [
+          status, headers, Rack::BodyProxy.new([]) do
+            body.close if body.respond_to? :close
+          end
+        ]
+      else
+        [status, headers, body]
+      end
     end
   end
 end
-
-end

data/lib/rack/lint.rb

@@ -15,8 +15,8 @@ module Rack
 
     class LintError < RuntimeError; end
     module Assertion
-      def assert(message, &block)
-        unless block.call
+      def assert(message)
+        unless yield
           raise LintError, message
         end
       end
@@ -42,8 +42,8 @@ module Rack
       assert("No env given") { env }
       check_env env
 
-      env['rack.input'] = InputWrapper.new(env['rack.input'])
-      env['rack.errors'] = ErrorWrapper.new(env['rack.errors'])
+      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)
@@ -57,7 +57,7 @@ module Rack
       ## and the *body*.
       check_content_type status, headers
       check_content_length status, headers
-      @head_request = env[REQUEST_METHOD] == "HEAD"
+      @head_request = env[REQUEST_METHOD] == HEAD
       [status, headers, self]
     end
 
@@ -95,7 +95,7 @@ module Rack
       ##                      empty string, if the request URL targets
       ##                      the application root and does not have a
       ##                      trailing slash. This value may be
-      ##                      percent-encoded when I originating from
+      ##                      percent-encoded when originating from
       ##                      a URL.
 
       ## <tt>QUERY_STRING</tt>:: The portion of the request URL that
@@ -177,7 +177,7 @@ module Rack
       ## <tt>rack.session</tt>:: A hash like interface for storing
       ##                         request session data.
       ##                         The store must implement:
-      if session = env['rack.session']
+      if session = env[RACK_SESSION]
         ##                         store(key, value)         (aliased as []=);
         assert("session #{session.inspect} must respond to store and []=") {
           session.respond_to?(:store) && session.respond_to?(:[]=)
@@ -201,7 +201,7 @@ module Rack
 
       ## <tt>rack.logger</tt>:: A common object interface for logging messages.
       ##                        The object must implement:
-      if logger = env['rack.logger']
+      if logger = env[RACK_LOGGER]
         ##                         info(message, &block)
         assert("logger #{logger.inspect} must respond to info") {
           logger.respond_to?(:info)
@@ -229,16 +229,16 @@ module Rack
       end
 
       ## <tt>rack.multipart.buffer_size</tt>:: An Integer hint to the multipart parser as to what chunk size to use for reads and writes.
-      if bufsize = env['rack.multipart.buffer_size']
+      if bufsize = env[RACK_MULTIPART_BUFFER_SIZE]
         assert("rack.multipart.buffer_size must be an Integer > 0 if specified") {
           bufsize.is_a?(Integer) && bufsize > 0
         }
       end
 
       ## <tt>rack.multipart.tempfile_factory</tt>:: An object responding to #call with two arguments, the filename and content_type given for the multipart form field, and returning an IO-like object that responds to #<< and optionally #rewind. This factory will be used to instantiate the tempfile for each multipart form file upload field, rather than the default class of Tempfile.
-      if tempfile_factory = env['rack.multipart.tempfile_factory']
+      if tempfile_factory = env[RACK_MULTIPART_TEMPFILE_FACTORY]
         assert("rack.multipart.tempfile_factory must respond to #call") { tempfile_factory.respond_to?(:call) }
-        env['rack.multipart.tempfile_factory'] = lambda do |filename, content_type|
+        env[RACK_MULTIPART_TEMPFILE_FACTORY] = lambda do |filename, content_type|
           io = tempfile_factory.call(filename, content_type)
           assert("rack.multipart.tempfile_factory return value must respond to #<<") { io.respond_to?(:<<) }
           io
@@ -279,37 +279,37 @@ module Rack
       ## 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"].kind_of? Array
+      assert("rack.version must be an Array, was #{env[RACK_VERSION].class}") {
+        env[RACK_VERSION].kind_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"]
+      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"]
+      check_input env[RACK_INPUT]
       ## * There must be a valid error stream in <tt>rack.errors</tt>.
-      check_error env["rack.errors"]
+      check_error env[RACK_ERRORS]
       ## * There may be a valid hijack stream in <tt>rack.hijack_io</tt>
       check_hijack env
 
       ## * The <tt>REQUEST_METHOD</tt> must be a valid token.
       assert("REQUEST_METHOD unknown: #{env[REQUEST_METHOD]}") {
-        env["REQUEST_METHOD"] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/
+        env[REQUEST_METHOD] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/
       }
 
       ## * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt>
       assert("SCRIPT_NAME must start with /") {
-        !env.include?("SCRIPT_NAME") ||
-        env["SCRIPT_NAME"] == "" ||
-        env["SCRIPT_NAME"] =~ /\A\//
+        !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\//
+        !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"]}") {
@@ -320,11 +320,11 @@ module Rack
       ##   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"]
+        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"] != "/"
+        env[SCRIPT_NAME] != "/"
       }
     end
 
@@ -518,11 +518,11 @@ module Rack
     #
     ## ==== Request (before status)
     def check_hijack(env)
-      if env['rack.hijack?']
+      if env[RACK_IS_HIJACK]
         ## If rack.hijack? is true then rack.hijack must respond to #call.
-        original_hijack = env['rack.hijack']
+        original_hijack = env[RACK_HIJACK]
         assert("rack.hijack must respond to call") { original_hijack.respond_to?(:call) }
-        env['rack.hijack'] = proc do
+        env[RACK_HIJACK] = proc do
           ## rack.hijack must return the io that will also be assigned (or is
           ## already present, in rack.hijack_io.
           io = original_hijack.call
@@ -548,16 +548,16 @@ module Rack
           ## hijack_io to provide additional features to users. The purpose of
           ## rack.hijack is for Rack to "get out of the way", as such, Rack only
           ## provides the minimum of specification and support.
-          env['rack.hijack_io'] = HijackWrapper.new(env['rack.hijack_io'])
+          env[RACK_HIJACK_IO] = HijackWrapper.new(env[RACK_HIJACK_IO])
           io
         end
       else
         ##
         ## If rack.hijack? is false, then rack.hijack should not be set.
-        assert("rack.hijack? is false, but rack.hijack is present") { env['rack.hijack'].nil? }
+        assert("rack.hijack? is false, but rack.hijack is present") { env[RACK_HIJACK].nil? }
         ##
         ## If rack.hijack? is false, then rack.hijack_io should not be set.
-        assert("rack.hijack? is false, but rack.hijack_io is present") { env['rack.hijack_io'].nil? }
+        assert("rack.hijack? is false, but rack.hijack_io is present") { env[RACK_HIJACK_IO].nil? }
       end
     end
 
@@ -587,12 +587,12 @@ module Rack
       ## Servers must ignore the <tt>body</tt> part of the response tuple when
       ## the <tt>rack.hijack</tt> response API is in use.
 
-      if env['rack.hijack?'] && headers['rack.hijack']
+      if env[RACK_IS_HIJACK] && headers[RACK_HIJACK]
         assert('rack.hijack header must respond to #call') {
-          headers['rack.hijack'].respond_to? :call
+          headers[RACK_HIJACK].respond_to? :call
         }
-        original_hijack = headers['rack.hijack']
-        headers['rack.hijack'] = proc do |io|
+        original_hijack = headers[RACK_HIJACK]
+        headers[RACK_HIJACK] = proc do |io|
           original_hijack.call HijackWrapper.new(io)
         end
       else
@@ -600,7 +600,7 @@ module Rack
         ## The special response header <tt>rack.hijack</tt> must only be set
         ## if the request env has <tt>rack.hijack?</tt> <tt>true</tt>.
         assert('rack.hijack header must not be present if server does not support hijacking') {
-          headers['rack.hijack'].nil?
+          headers[RACK_HIJACK].nil?
         }
       end
     end
@@ -710,7 +710,7 @@ module Rack
         assert("Body yielded non-string value #{part.inspect}") {
           part.kind_of? String
         }
-        bytes += Rack::Utils.bytesize(part)
+        bytes += part.bytesize
         yield part
       }
       verify_content_length(bytes)

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,6 @@ 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"
-    rescue EOFError
-      req.env["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",