rack 1.6.11 → 2.2.0

data/lib/rack/mime.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   module Mime
     # Returns String with mime type if found, otherwise use +fallback+.
@@ -13,7 +15,7 @@ module Rack
     # This is a shortcut for:
     #     Rack::Mime::MIME_TYPES.fetch('.foo', 'application/octet-stream')
 
-    def mime_type(ext, fallback='application/octet-stream')
+    def mime_type(ext, fallback = 'application/octet-stream')
       MIME_TYPES.fetch(ext.to_s.downcase, fallback)
     end
     module_function :mime_type
@@ -45,11 +47,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 +151,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",
@@ -308,6 +308,7 @@ module Rack
       ".lvp"       => "audio/vnd.lucent.voice",
       ".lwp"       => "application/vnd.lotus-wordpro",
       ".m3u"       => "audio/x-mpegurl",
+      ".m3u8"      => "application/x-mpegurl",
       ".m4a"       => "audio/mp4a-latm",
       ".m4v"       => "video/mp4",
       ".ma"        => "application/mathematica",
@@ -345,6 +346,7 @@ module Rack
       ".mp4s"      => "application/mp4",
       ".mp4v"      => "video/mp4",
       ".mpc"       => "application/vnd.mophun.certificate",
+      ".mpd"       => "application/dash+xml",
       ".mpeg"      => "video/mpeg",
       ".mpg"       => "video/mpeg",
       ".mpga"      => "audio/mpeg",
@@ -444,10 +446,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",
@@ -535,6 +546,7 @@ module Rack
       ".spp"       => "application/scvp-vp-response",
       ".spq"       => "application/scvp-vp-request",
       ".src"       => "application/x-wais-source",
+      ".srt"       => "text/srt",
       ".srx"       => "application/sparql-results+xml",
       ".sse"       => "application/vnd.kodak-descriptor",
       ".ssf"       => "application/vnd.epson.ssf",
@@ -569,6 +581,7 @@ module Rack
       ".tr"        => "text/troff",
       ".tra"       => "application/vnd.trueapp",
       ".trm"       => "application/x-msterminal",
+      ".ts"        => "video/mp2t",
       ".tsv"       => "text/tab-separated-values",
       ".ttf"       => "application/octet-stream",
       ".twd"       => "application/vnd.simtech-mindmapper",
@@ -593,9 +606,11 @@ module Rack
       ".vrml"      => "model/vrml",
       ".vsd"       => "application/vnd.visio",
       ".vsf"       => "application/vnd.vsf",
+      ".vtt"       => "text/vtt",
       ".vtu"       => "model/vnd.vtu",
       ".vxml"      => "application/voicexml+xml",
       ".war"       => "application/java-archive",
+      ".wasm"      => "application/wasm",
       ".wav"       => "audio/x-wav",
       ".wax"       => "audio/x-ms-wax",
       ".wbmp"      => "image/vnd.wap.wbmp",
@@ -638,8 +653,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

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require 'uri'
 require 'stringio'
-require 'rack'
-require 'rack/lint'
-require 'rack/utils'
-require 'rack/response'
+require_relative '../rack'
+require 'cgi/cookie'
 
 module Rack
   # Rack::MockRequest helps testing your Rack application without
@@ -41,28 +41,38 @@ 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 request(method="GET", uri="", opts={})
-      env = self.class.env_for(uri, opts.merge(:method => method))
+    # Make a GET request and return a MockResponse. See #request.
+    def get(uri, opts = {})     request(GET, uri, opts)     end
+    # Make a POST request and return a MockResponse. See #request.
+    def post(uri, opts = {})    request(POST, uri, opts)    end
+    # Make a PUT request and return a MockResponse. See #request.
+    def put(uri, opts = {})     request(PUT, uri, opts)     end
+    # Make a PATCH request and return a MockResponse. See #request.
+    def patch(uri, opts = {})   request(PATCH, uri, opts)   end
+    # Make a DELETE request and return a MockResponse. See #request.
+    def delete(uri, opts = {})  request(DELETE, uri, opts)  end
+    # Make a HEAD request and return a MockResponse. See #request.
+    def head(uri, opts = {})    request(HEAD, uri, opts)    end
+    # Make an OPTIONS request and return a MockResponse. See #request.
+    def options(uri, opts = {}) request(OPTIONS, uri, opts) end
+
+    # Make a request using the given request method for the given
+    # uri to the rack application and return a MockResponse.
+    # Options given are passed to MockRequest.env_for.
+    def request(method = GET, uri = "", opts = {})
+      env = self.class.env_for(uri, opts.merge(method: method))
 
       if opts[:lint]
         app = Rack::Lint.new(@app)
@@ -70,49 +80,62 @@ module Rack
         app = @app
       end
 
-      errors = env["rack.errors"]
-      status, headers, body  = app.call(env)
+      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
 
     # Return the Rack environment used for a request to +uri+.
-    def self.env_for(uri="", opts={})
+    # All options that are strings are added to the returned environment.
+    # Options:
+    # :fatal :: Whether to raise an exception if request outputs to rack.errors
+    # :input :: The rack.input to set
+    # :method :: The HTTP request method to use
+    # :params :: The params to use
+    # :script_name :: The SCRIPT_NAME to set
+    def self.env_for(uri = "", opts = {})
       uri = parse_uri_rfc2396(uri)
       uri.path = "/#{uri.path}" unless uri.path[0] == ?/
 
       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 +145,7 @@ module Rack
         end
       end
 
-      empty_str = ""
-      empty_str.force_encoding("ASCII-8BIT") if empty_str.respond_to? :force_encoding
+      empty_str = String.new
       opts[:input] ||= empty_str
       if String === opts[:input]
         rack_input = StringIO.new(opts[:input])
@@ -131,10 +153,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].size.to_s if env[RACK_INPUT].respond_to?(:size)
 
       opts.each { |field, value|
         env[field] = value  if String === field
@@ -142,28 +164,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.
@@ -171,18 +171,24 @@ module Rack
   # MockRequest.
 
   class MockResponse < Rack::Response
+    class << self
+      alias [] new
+    end
+
     # Headers
-    attr_reader :original_headers
+    attr_reader :original_headers, :cookies
 
     # Errors
     attr_accessor :errors
 
-    def initialize(status, headers, body, errors=StringIO.new(""))
+    def initialize(status, headers, body, errors = StringIO.new(""))
       @original_headers = headers
       @errors           = errors.string if errors.respond_to?(:string)
-      @body_string      = nil
+      @cookies = parse_cookies_from_header
 
       super(body, status, headers)
+
+      buffered_body!
     end
 
     def =~(other)
@@ -204,11 +210,64 @@ module Rack
       #     ...
       #     res.body.should == "foo!"
       #   end
-      super.join
+      buffer = String.new
+
+      super.each do |chunk|
+        buffer << chunk
+      end
+
+      return buffer
     end
 
     def empty?
-      [201, 204, 205, 304].include? status
+      [201, 204, 304].include? status
     end
+
+    def cookie(name)
+      cookies.fetch(name, nil)
+    end
+
+    private
+
+    def parse_cookies_from_header
+      cookies = Hash.new
+      if original_headers.has_key? 'Set-Cookie'
+        set_cookie_header = original_headers.fetch('Set-Cookie')
+        set_cookie_header.split("\n").each do |cookie|
+          cookie_name, cookie_filling = cookie.split('=', 2)
+          cookie_attributes = identify_cookie_attributes cookie_filling
+          parsed_cookie = CGI::Cookie.new(
+            'name' => cookie_name.strip,
+            'value' => cookie_attributes.fetch('value'),
+            'path' => cookie_attributes.fetch('path', nil),
+            'domain' => cookie_attributes.fetch('domain', nil),
+            'expires' => cookie_attributes.fetch('expires', nil),
+            'secure' => cookie_attributes.fetch('secure', false)
+          )
+          cookies.store(cookie_name, parsed_cookie)
+        end
+      end
+      cookies
+    end
+
+    def identify_cookie_attributes(cookie_filling)
+      cookie_bits = cookie_filling.split(';')
+      cookie_attributes = Hash.new
+      cookie_attributes.store('value', cookie_bits[0].strip)
+      cookie_bits.each do |bit|
+        if bit.include? '='
+          cookie_attribute, attribute_value = bit.split('=')
+          cookie_attributes.store(cookie_attribute.strip, attribute_value.strip)
+          if cookie_attribute.include? 'max-age'
+            cookie_attributes.store('expires', Time.now + attribute_value.strip.to_i)
+          end
+        end
+        if bit.include? 'secure'
+          cookie_attributes.store('secure', true)
+        end
+      end
+      cookie_attributes
+    end
+
   end
 end

data/lib/rack/multipart/generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   module Multipart
     class Generator
@@ -11,37 +13,38 @@ 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)
-              content_for_tempfile(f, file, name)
+            if file.path
+              ::File.open(file.path, 'rb') do |f|
+                f.set_encoding(Encoding::BINARY)
+                content_for_tempfile(f, file, name)
+              end
+            else
+              content_for_tempfile(file, file, name)
             end
           else
             content_for_other(file, name)
           end
-        end.join + "--#{MULTIPART_BOUNDARY}--\r"
+        end.join << "--#{MULTIPART_BOUNDARY}--\r"
       end
 
       private
       def multipart?
-        multipart = false
-
         query = lambda { |value|
           case value
           when Array
-            value.each(&query)
+            value.any?(&query)
           when Hash
-            value.values.each(&query)
+            value.values.any?(&query)
           when Rack::Multipart::UploadedFile
-            multipart = true
+            true
           end
         }
-        @params.values.each(&query)
 
-        multipart
+        @params.values.any?(&query)
       end
 
       def flattened_params
@@ -70,12 +73,13 @@ module Rack
       end
 
       def content_for_tempfile(io, file, name)
+        length = ::File.stat(file.path).size if file.path
+        filename = "; filename=\"#{Utils.escape(file.original_filename)}\"" if file.original_filename
 <<-EOF
 --#{MULTIPART_BOUNDARY}\r
-Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
+Content-Disposition: form-data; name="#{name}"#{filename}\r
 Content-Type: #{file.content_type}\r
-Content-Length: #{::File.stat(file.path).size}\r
-\r
+#{"Content-Length: #{length}\r\n" if length}\r
 #{io.read}\r
 EOF
       end
@@ -90,4 +94,4 @@ EOF
       end
     end
   end
-end
+end