rack 1.1.6 → 1.6.9

data/lib/rack/mock.rb

@@ -1,5 +1,6 @@
 require 'uri'
 require 'stringio'
+require 'rack'
 require 'rack/lint'
 require 'rack/utils'
 require 'rack/response'
@@ -8,12 +9,12 @@ 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
+  # After performing a request on a URL with get/post/put/patch/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.
+  # get/post/put/patch/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.
@@ -40,7 +41,7 @@ module Rack
     end
 
     DEFAULT_ENV = {
-      "rack.version" => [1,1],
+      "rack.version" => Rack::VERSION,
       "rack.input" => StringIO.new,
       "rack.errors" => StringIO.new,
       "rack.multithread" => true,
@@ -52,10 +53,13 @@ module Rack
       @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 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))
@@ -67,25 +71,29 @@ module Rack
       end
 
       errors = env["rack.errors"]
-      MockResponse.new(*(app.call(env) + [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.
+    def self.parse_uri_rfc2396(uri)
+      @parser ||= defined?(URI::RFC2396_Parser) ? URI::RFC2396_Parser.new : URI
+      @parser.parse(uri)
     end
 
     # Return the Rack environment used for a request to +uri+.
     def self.env_for(uri="", opts={})
-      uri = URI(uri)
+      uri = parse_uri_rfc2396(uri)
       uri.path = "/#{uri.path}" unless uri.path[0] == ?/
 
       env = DEFAULT_ENV.dup
 
-      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"
+      env_with_encoding(env, opts, uri)
 
-      env["SCRIPT_NAME"] = opts[:script_name] || ""
+      env[SCRIPT_NAME] = opts[:script_name] || ""
 
       if opts[:fatal]
         env["rack.errors"] = FatalWarner.new
@@ -94,10 +102,10 @@ module Rack
       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)
+          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)
@@ -134,56 +142,73 @@ 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.
   # 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|
-        @headers[field] = values
-        @headers[field] = ""  if values.empty?
-      }
-
-      @body = ""
-      body.each { |part| @body << part }
-
-      @errors = errors.string if errors.respond_to?(:string)
-    end
-
-    # Status
-    attr_reader :status
-
+  class MockResponse < Rack::Response
     # Headers
-    attr_reader :headers, :original_headers
+    attr_reader :original_headers
 
-    def [](field)
-      headers[field]
-    end
+    # Errors
+    attr_accessor :errors
 
+    def initialize(status, headers, body, errors=StringIO.new(""))
+      @original_headers = headers
+      @errors           = errors.string if errors.respond_to?(:string)
+      @body_string      = nil
 
-    # Body
-    attr_reader :body
+      super(body, status, headers)
+    end
 
     def =~(other)
-      @body =~ other
+      body =~ other
     end
 
     def match(other)
-      @body.match other
+      body.match other
     end
 
+    def body
+      # FIXME: apparently users of MockResponse expect the return value of
+      # MockResponse#body to be a string.  However, the real response object
+      # returns the body as a list.
+      #
+      # See spec_showstatus.rb:
+      #
+      #   should "not replace existing messages" do
+      #     ...
+      #     res.body.should == "foo!"
+      #   end
+      super.join
+    end
 
-    # Errors
-    attr_accessor :errors
-
-
-    include Response::Helpers
+    def empty?
+      [201, 204, 205, 304].include? status
+    end
   end
 end

data/lib/rack/multipart/generator.rb

@@ -0,0 +1,93 @@
+module Rack
+  module Multipart
+    class Generator
+      def initialize(params, first = true)
+        @params, @first = params, first
+
+        if @first && !@params.is_a?(Hash)
+          raise ArgumentError, "value must be a Hash"
+        end
+      end
+
+      def dump
+        return nil if @first && !multipart?
+        return flattened_params if !@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)
+            end
+          else
+            content_for_other(file, name)
+          end
+        end.join + "--#{MULTIPART_BOUNDARY}--\r"
+      end
+
+      private
+      def multipart?
+        multipart = false
+
+        query = lambda { |value|
+          case value
+          when Array
+            value.each(&query)
+          when Hash
+            value.values.each(&query)
+          when Rack::Multipart::UploadedFile
+            multipart = true
+          end
+        }
+        @params.values.each(&query)
+
+        multipart
+      end
+
+      def flattened_params
+        @flattened_params ||= begin
+          h = Hash.new
+          @params.each do |key, value|
+            k = @first ? key.to_s : "[#{key}]"
+
+            case value
+            when Array
+              value.map { |v|
+                Multipart.build_multipart(v, false).each { |subkey, subvalue|
+                  h["#{k}[]#{subkey}"] = subvalue
+                }
+              }
+            when Hash
+              Multipart.build_multipart(value, false).each { |subkey, subvalue|
+                h[k + subkey] = subvalue
+              }
+            else
+              h[k] = value
+            end
+          end
+          h
+        end
+      end
+
+      def content_for_tempfile(io, file, name)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
+Content-Type: #{file.content_type}\r
+Content-Length: #{::File.stat(file.path).size}\r
+\r
+#{io.read}\r
+EOF
+      end
+
+      def content_for_other(file, name)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"\r
+\r
+#{file}\r
+EOF
+      end
+    end
+  end
+end

data/lib/rack/multipart/parser.rb

@@ -0,0 +1,253 @@
+require 'rack/utils'
+
+module Rack
+  module Multipart
+    class MultipartPartLimitError < Errno::EMFILE; end
+
+    class Parser
+      BUFSIZE = 16384
+      DUMMY = Struct.new(:parse).new
+
+      def self.create(env)
+        return DUMMY unless env['CONTENT_TYPE'] =~ MULTIPART
+
+        io = env['rack.input']
+        io.rewind
+
+        content_length = env['CONTENT_LENGTH']
+        content_length = content_length.to_i if content_length
+
+        tempfile = env['rack.multipart.tempfile_factory'] ||
+          lambda { |filename, content_type| Tempfile.new(["RackMultipart", ::File.extname(filename.gsub("\0".freeze, '%00'.freeze))]) }
+        bufsize = env['rack.multipart.buffer_size'] || BUFSIZE
+
+        new($1, io, content_length, env, tempfile, bufsize)
+      end
+
+      def initialize(boundary, io, content_length, env, tempfile, bufsize)
+        @buf            = ""
+
+        if @buf.respond_to? :force_encoding
+          @buf.force_encoding Encoding::ASCII_8BIT
+        end
+
+        @params         = Utils::KeySpaceConstrainedParams.new
+        @boundary       = "--#{boundary}"
+        @io             = io
+        @content_length = content_length
+        @boundary_size  = Utils.bytesize(@boundary) + EOL.size
+        @env = env
+        @tempfile       = tempfile
+        @bufsize        = bufsize
+
+        if @content_length
+          @content_length -= @boundary_size
+        end
+
+        @rx = /(?:#{EOL})?#{Regexp.quote(@boundary)}(#{EOL}|--)/n
+        @full_boundary = @boundary + EOL
+      end
+
+      def parse
+        fast_forward_to_first_boundary
+
+        opened_files = 0
+        loop do
+
+          head, filename, content_type, name, body =
+            get_current_head_and_filename_and_content_type_and_name_and_body
+
+          if Utils.multipart_part_limit > 0
+            opened_files += 1 if filename
+            raise MultipartPartLimitError, 'Maximum file multiparts in content reached' if opened_files >= Utils.multipart_part_limit
+          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
+
+          get_data(filename, body, content_type, name, head) do |data|
+            tag_multipart_encoding(filename, content_type, name, data)
+
+            Utils.normalize_params(@params, name, data)
+          end
+
+          # break if we're at the end of a buffer, but not if it is the end of a field
+          break if (@buf.empty? && $1 != EOL) || @content_length == -1
+        end
+
+        @io.rewind
+
+        @params.to_params_hash
+      end
+
+      private
+      def full_boundary; @full_boundary; end
+
+      def rx; @rx; end
+
+      def fast_forward_to_first_boundary
+        loop do
+          content = @io.read(@bufsize)
+          raise EOFError, "bad content body" unless content
+          @buf << content
+
+          while @buf.gsub!(/\A([^\n]*\n)/, '')
+            read_buffer = $1
+            return if read_buffer == full_boundary
+          end
+
+          raise EOFError, "bad content body" if Utils.bytesize(@buf) >= @bufsize
+        end
+      end
+
+      def get_current_head_and_filename_and_content_type_and_name_and_body
+        head = nil
+        body = ''
+
+        if body.respond_to? :force_encoding
+          body.force_encoding Encoding::ASCII_8BIT
+        end
+
+        filename = content_type = name = nil
+
+        until head && @buf =~ rx
+          if !head && i = @buf.index(EOL+EOL)
+            head = @buf.slice!(0, i+2) # First \r\n
+
+            @buf.slice!(0, 2)          # Second \r\n
+
+            content_type = head[MULTIPART_CONTENT_TYPE, 1]
+            name = head[MULTIPART_CONTENT_DISPOSITION, 1] || head[MULTIPART_CONTENT_ID, 1]
+
+            filename = get_filename(head)
+
+            if name.nil? || name.empty? && filename
+              name = filename
+            end
+
+            if filename
+              (@env['rack.tempfiles'] ||= []) << body = @tempfile.call(filename, content_type)
+              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
+
+          content = @io.read(@content_length && @bufsize >= @content_length ? @content_length : @bufsize)
+          raise EOFError, "bad content body"  if content.nil? || content.empty?
+
+          @buf << content
+          @content_length -= content.size if @content_length
+        end
+
+        [head, filename, content_type, name, body]
+      end
+
+      def get_filename(head)
+        filename = nil
+        case head
+        when RFC2183
+          filename = Hash[head.scan(DISPPARM)]['filename']
+          filename = $1 if filename and filename =~ /^"(.*)"$/
+        when BROKEN_QUOTED, BROKEN_UNQUOTED
+          filename = $1
+        end
+
+        return unless filename
+
+        if filename.scan(/%.?.?/).all? { |s| s =~ /%[0-9a-fA-F]{2}/ }
+          filename = Utils.unescape(filename)
+        end
+
+        scrub_filename filename
+
+        if filename !~ /\\[^\\"]/
+          filename = filename.gsub(/\\(.)/, '\1')
+        end
+        filename
+      end
+
+      if "<3".respond_to? :valid_encoding?
+        def scrub_filename(filename)
+          unless filename.valid_encoding?
+            # FIXME: this force_encoding is for Ruby 2.0 and 1.9 support.
+            # We can remove it after they are dropped
+            filename.force_encoding(Encoding::ASCII_8BIT)
+            filename.encode!(:invalid => :replace, :undef => :replace)
+          end
+        end
+
+        CHARSET    = "charset"
+        TEXT_PLAIN = "text/plain"
+
+        def tag_multipart_encoding(filename, content_type, name, body)
+          name.force_encoding Encoding::UTF_8
+
+          return if filename
+
+          encoding = Encoding::UTF_8
+
+          if content_type
+            list         = content_type.split(';')
+            type_subtype = list.first
+            type_subtype.strip!
+            if TEXT_PLAIN == type_subtype
+              rest         = list.drop 1
+              rest.each do |param|
+                k,v = param.split('=', 2)
+                k.strip!
+                v.strip!
+                encoding = Encoding.find v if k == CHARSET
+              end
+            end
+          end
+
+          name.force_encoding encoding
+          body.force_encoding encoding
+        end
+      else
+        def scrub_filename(filename)
+        end
+        def tag_multipart_encoding(filename, content_type, name, body)
+        end
+      end
+
+      def get_data(filename, body, content_type, name, head)
+        data = body
+        if filename == ""
+          # filename is blank which means no file has been selected
+          return
+        elsif filename
+          body.rewind if body.respond_to?(:rewind)
+
+          # Take the basename of the upload's original filename.
+          # This handles the full Windows paths given by Internet Explorer
+          # (and perhaps other broken user agents) without affecting
+          # those which give the lone filename.
+          filename = filename.split(/[\/\\]/).last
+
+          data = {:filename => filename, :type => content_type,
+                  :name => name, :tempfile => body, :head => head}
+        elsif !filename && content_type && body.is_a?(IO)
+          body.rewind
+
+          # Generic multipart cases, not coming from a form
+          data = {:type => content_type,
+                  :name => name, :tempfile => body, :head => head}
+        end
+
+        yield data
+      end
+    end
+  end
+end

data/lib/rack/multipart/uploaded_file.rb

@@ -0,0 +1,34 @@
+module Rack
+  module Multipart
+    class UploadedFile
+      # The filename, *not* including the path, of the "uploaded" file
+      attr_reader :original_filename
+
+      # The content type of the "uploaded" file
+      attr_accessor :content_type
+
+      def initialize(path, content_type = "text/plain", binary = false)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+        @content_type = content_type
+        @original_filename = ::File.basename(path)
+        @tempfile = Tempfile.new([@original_filename, ::File.extname(path)])
+        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+        @tempfile.binmode if binary
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+
+      def path
+        @tempfile.path
+      end
+      alias_method :local_path, :path
+
+      def respond_to?(*args)
+        super or @tempfile.respond_to?(*args)
+      end
+
+      def method_missing(method_name, *args, &block) #:nodoc:
+        @tempfile.__send__(method_name, *args, &block)
+      end
+    end
+  end
+end

data/lib/rack/multipart.rb

@@ -0,0 +1,34 @@
+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"
+    MULTIPART_BOUNDARY = "AaB03x"
+    MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|ni
+    TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/
+    CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i
+    DISPPARM = /;\s*(#{TOKEN})=("(?:\\"|[^"])*"|#{TOKEN})/
+    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
+    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_ID = /Content-ID:\s*([^#{EOL}]*)/ni
+
+    class << self
+      def parse_multipart(env)
+        Parser.create(env).parse
+      end
+
+      def build_multipart(params, first = true)
+        Generator.new(params, first).dump
+      end
+    end
+
+  end
+end

data/lib/rack/nulllogger.rb

@@ -9,10 +9,29 @@ module Rack
       @app.call(env)
     end
 
-    def info(progname = nil, &block);  end
+    def info(progname = nil, &block); end
     def debug(progname = nil, &block); end
-    def warn(progname = nil, &block);  end
+    def warn(progname = nil, &block); end
     def error(progname = nil, &block); end
     def fatal(progname = nil, &block); end
+    def unknown(progname = nil, &block); end
+    def info? ;  end
+    def debug? ; end
+    def warn? ;  end
+    def error? ; end
+    def fatal? ; end
+    def level ; end
+    def progname ; end
+    def datetime_format ; end
+    def formatter ; end
+    def sev_threshold ; end
+    def level=(level); end
+    def progname=(progname); end
+    def datetime_format=(datetime_format); end
+    def formatter=(formatter); end
+    def sev_threshold=(sev_threshold); end
+    def close ; end
+    def add(severity, message = nil, progname = nil, &block); end
+    def <<(msg); end
   end
 end

data/lib/rack/recursive.rb

@@ -14,8 +14,8 @@ module Rack
       @url = URI(url)
       @env = env
 
-      @env["PATH_INFO"] =       @url.path
-      @env["QUERY_STRING"] =    @url.query  if @url.query
+      @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
@@ -35,7 +35,11 @@ module Rack
     end
 
     def call(env)
-      @script_name = env["SCRIPT_NAME"]
+      dup._call(env)
+    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))
@@ -47,8 +51,9 @@ module Rack
         raise ArgumentError, "can only include below #{@script_name}, not #{path}"
       end
 
-      env = env.merge("PATH_INFO" => path, "SCRIPT_NAME" => @script_name,
-                      "REQUEST_METHOD" => "GET",
+      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)