RubyGems - edgar-rack - Versions diffs - 1.2.1 - Mend

edgar-rack 1.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (138) hide show

data/COPYING +18 -0
data/KNOWN-ISSUES +21 -0
data/README +401 -0
data/Rakefile +101 -0
data/SPEC +171 -0
data/bin/rackup +4 -0
data/contrib/rack_logo.svg +111 -0
data/example/lobster.ru +4 -0
data/example/protectedlobster.rb +14 -0
data/example/protectedlobster.ru +8 -0
data/lib/rack.rb +81 -0
data/lib/rack/auth/abstract/handler.rb +37 -0
data/lib/rack/auth/abstract/request.rb +43 -0
data/lib/rack/auth/basic.rb +58 -0
data/lib/rack/auth/digest/md5.rb +124 -0
data/lib/rack/auth/digest/nonce.rb +51 -0
data/lib/rack/auth/digest/params.rb +53 -0
data/lib/rack/auth/digest/request.rb +40 -0
data/lib/rack/builder.rb +80 -0
data/lib/rack/cascade.rb +41 -0
data/lib/rack/chunked.rb +52 -0
data/lib/rack/commonlogger.rb +49 -0
data/lib/rack/conditionalget.rb +63 -0
data/lib/rack/config.rb +15 -0
data/lib/rack/content_length.rb +29 -0
data/lib/rack/content_type.rb +23 -0
data/lib/rack/deflater.rb +96 -0
data/lib/rack/directory.rb +157 -0
data/lib/rack/etag.rb +59 -0
data/lib/rack/file.rb +118 -0
data/lib/rack/handler.rb +88 -0
data/lib/rack/handler/cgi.rb +61 -0
data/lib/rack/handler/evented_mongrel.rb +8 -0
data/lib/rack/handler/fastcgi.rb +90 -0
data/lib/rack/handler/lsws.rb +61 -0
data/lib/rack/handler/mongrel.rb +90 -0
data/lib/rack/handler/scgi.rb +59 -0
data/lib/rack/handler/swiftiplied_mongrel.rb +8 -0
data/lib/rack/handler/thin.rb +17 -0
data/lib/rack/handler/webrick.rb +73 -0
data/lib/rack/head.rb +19 -0
data/lib/rack/lint.rb +567 -0
data/lib/rack/lobster.rb +65 -0
data/lib/rack/lock.rb +44 -0
data/lib/rack/logger.rb +18 -0
data/lib/rack/methodoverride.rb +27 -0
data/lib/rack/mime.rb +210 -0
data/lib/rack/mock.rb +185 -0
data/lib/rack/nulllogger.rb +18 -0
data/lib/rack/recursive.rb +61 -0
data/lib/rack/reloader.rb +109 -0
data/lib/rack/request.rb +307 -0
data/lib/rack/response.rb +151 -0
data/lib/rack/rewindable_input.rb +104 -0
data/lib/rack/runtime.rb +27 -0
data/lib/rack/sendfile.rb +139 -0
data/lib/rack/server.rb +289 -0
data/lib/rack/session/abstract/id.rb +348 -0
data/lib/rack/session/cookie.rb +152 -0
data/lib/rack/session/memcache.rb +93 -0
data/lib/rack/session/pool.rb +79 -0
data/lib/rack/showexceptions.rb +378 -0
data/lib/rack/showstatus.rb +113 -0
data/lib/rack/static.rb +53 -0
data/lib/rack/urlmap.rb +55 -0
data/lib/rack/utils.rb +698 -0
data/rack.gemspec +39 -0
data/test/cgi/lighttpd.conf +25 -0
data/test/cgi/rackup_stub.rb +6 -0
data/test/cgi/sample_rackup.ru +5 -0
data/test/cgi/test +9 -0
data/test/cgi/test.fcgi +8 -0
data/test/cgi/test.ru +5 -0
data/test/gemloader.rb +6 -0
data/test/multipart/bad_robots +259 -0
data/test/multipart/binary +0 -0
data/test/multipart/empty +10 -0
data/test/multipart/fail_16384_nofile +814 -0
data/test/multipart/file1.txt +1 -0
data/test/multipart/filename_and_modification_param +7 -0
data/test/multipart/filename_with_escaped_quotes +6 -0
data/test/multipart/filename_with_escaped_quotes_and_modification_param +7 -0
data/test/multipart/filename_with_percent_escaped_quotes +6 -0
data/test/multipart/filename_with_unescaped_quotes +6 -0
data/test/multipart/ie +6 -0
data/test/multipart/nested +10 -0
data/test/multipart/none +9 -0
data/test/multipart/semicolon +6 -0
data/test/multipart/text +15 -0
data/test/rackup/config.ru +31 -0
data/test/spec_auth_basic.rb +70 -0
data/test/spec_auth_digest.rb +241 -0
data/test/spec_builder.rb +123 -0
data/test/spec_cascade.rb +45 -0
data/test/spec_cgi.rb +102 -0
data/test/spec_chunked.rb +60 -0
data/test/spec_commonlogger.rb +56 -0
data/test/spec_conditionalget.rb +86 -0
data/test/spec_config.rb +23 -0
data/test/spec_content_length.rb +36 -0
data/test/spec_content_type.rb +29 -0
data/test/spec_deflater.rb +125 -0
data/test/spec_directory.rb +57 -0
data/test/spec_etag.rb +75 -0
data/test/spec_fastcgi.rb +107 -0
data/test/spec_file.rb +92 -0
data/test/spec_handler.rb +49 -0
data/test/spec_head.rb +30 -0
data/test/spec_lint.rb +515 -0
data/test/spec_lobster.rb +43 -0
data/test/spec_lock.rb +142 -0
data/test/spec_logger.rb +28 -0
data/test/spec_methodoverride.rb +58 -0
data/test/spec_mock.rb +241 -0
data/test/spec_mongrel.rb +182 -0
data/test/spec_nulllogger.rb +12 -0
data/test/spec_recursive.rb +69 -0
data/test/spec_request.rb +774 -0
data/test/spec_response.rb +245 -0
data/test/spec_rewindable_input.rb +118 -0
data/test/spec_runtime.rb +39 -0
data/test/spec_sendfile.rb +83 -0
data/test/spec_server.rb +8 -0
data/test/spec_session_abstract_id.rb +43 -0
data/test/spec_session_cookie.rb +171 -0
data/test/spec_session_memcache.rb +289 -0
data/test/spec_session_pool.rb +200 -0
data/test/spec_showexceptions.rb +87 -0
data/test/spec_showstatus.rb +79 -0
data/test/spec_static.rb +48 -0
data/test/spec_thin.rb +86 -0
data/test/spec_urlmap.rb +213 -0
data/test/spec_utils.rb +678 -0
data/test/spec_webrick.rb +141 -0
data/test/testrequest.rb +78 -0
data/test/unregistered_handler/rack/handler/unregistered.rb +7 -0
data/test/unregistered_handler/rack/handler/unregistered_long_one.rb +7 -0
metadata +329 -0

data/lib/rack/showstatus.rb ADDED

@@ -0,0 +1,113 @@
+require 'erb'
+require 'rack/request'
+require 'rack/utils'
+module Rack
+  # Rack::ShowStatus catches all empty responses the app it wraps and
+  # replaces them with a site explaining the error.
+  #
+  # Additional details can be put into <tt>rack.showstatus.detail</tt>
+  # and will be shown as HTML.  If such details exist, the error page
+  # is always rendered, even if the reply was not empty.
+  class ShowStatus
+    def initialize(app)
+      @app = app
+      @template = ERB.new(TEMPLATE)
+    end
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+      empty = headers['Content-Length'].to_i <= 0
+      # client or server error, or explicit message
+      if (status.to_i >= 400 && empty) || env["rack.showstatus.detail"]
+        # This double assignment is to prevent an "unused variable" warning on
+        # Ruby 1.9.3.  Yes, it is dumb, but I don't like Ruby yelling at me.
+        req = req = Rack::Request.new(env)
+        message = Rack::Utils::HTTP_STATUS_CODES[status.to_i] || status.to_s
+        # This double assignment is to prevent an "unused variable" warning on
+        # Ruby 1.9.3.  Yes, it is dumb, but I don't like Ruby yelling at me.
+        detail = detail = env["rack.showstatus.detail"] || message
+        body = @template.result(binding)
+        size = Rack::Utils.bytesize(body)
+        [status, headers.merge("Content-Type" => "text/html", "Content-Length" => size.to_s), [body]]
+      else
+        [status, headers, body]
+      end
+    end
+    def h(obj)                  # :nodoc:
+      case obj
+      when String
+        Utils.escape_html(obj)
+      else
+        Utils.escape_html(obj.inspect)
+      end
+    end
+    # :stopdoc:
+# adapted from Django <djangoproject.com>
+# Copyright (c) 2005, the Lawrence Journal-World
+# Used under the modified BSD license:
+# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+TEMPLATE = <<'HTML'
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <title><%=h message %> at <%=h req.script_name + req.path_info %></title>
+  <meta name="robots" content="NONE,NOARCHIVE" />
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; background:#eee; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; margin-bottom:.4em; }
+    h1 span { font-size:60%; color:#666; font-weight:normal; }
+    table { border:none; border-collapse: collapse; width:100%; }
+    td, th { vertical-align:top; padding:2px 3px; }
+    th { width:12em; text-align:right; color:#666; padding-right:.5em; }
+    #info { background:#f6f6f6; }
+    #info ol { margin: 0.5em 4em; }
+    #info ol li { font-family: monospace; }
+    #summary { background: #ffc; }
+    #explanation { background:#eee; border-bottom: 0px none; }
+  </style>
+</head>
+<body>
+  <div id="summary">
+    <h1><%=h message %> <span>(<%= status.to_i %>)</span></h1>
+    <table class="meta">
+      <tr>
+        <th>Request Method:</th>
+        <td><%=h req.request_method %></td>
+      </tr>
+      <tr>
+        <th>Request URL:</th>
+      <td><%=h req.url %></td>
+      </tr>
+    </table>
+  </div>
+  <div id="info">
+    <p><%= detail %></p>
+  </div>
+  <div id="explanation">
+    <p>
+    You're seeing this error because you use <code>Rack::ShowStatus</code>.
+    </p>
+  </div>
+</body>
+</html>
+HTML
+    # :startdoc:
+  end
+end

data/lib/rack/static.rb ADDED

@@ -0,0 +1,53 @@
+module Rack
+  # The Rack::Static middleware intercepts requests for static files
+  # (javascript files, images, stylesheets, etc) based on the url prefixes or
+  # route mappings passed in the options, and serves them using a Rack::File
+  # object. This allows a Rack stack to serve both static and dynamic content.
+  #
+  # Examples:
+  #
+  # Serve all requests beginning with /media from the "media" folder located
+  # in the current directory (ie media/*):
+  #
+  #     use Rack::Static, :urls => ["/media"]
+  #
+  # Serve all requests beginning with /css or /images from the folder "public"
+  # in the current directory (ie public/css/* and public/images/*):
+  #
+  #     use Rack::Static, :urls => ["/css", "/images"], :root => "public"
+  #
+  # Serve all requests to / with "index.html" from the folder "public" in the
+  # current directory (ie public/index.html):
+  #
+  #     use Rack::Static, :urls => {"/" => 'index.html'}, :root => 'public'
+  #
+  class Static
+    def initialize(app, options={})
+      @app = app
+      @urls = options[:urls] || ["/favicon.ico"]
+      root = options[:root] || Dir.pwd
+      @file_server = Rack::File.new(root)
+    end
+    def call(env)
+      path = env["PATH_INFO"]
+      unless @urls.kind_of? Hash
+        can_serve = @urls.any? { |url| path.index(url) == 0 }
+      else
+        can_serve = @urls.key? path
+      end
+      if can_serve
+        env["PATH_INFO"] = @urls[path] if @urls.kind_of? Hash
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/rack/urlmap.rb ADDED

@@ -0,0 +1,55 @@
+module Rack
+  # Rack::URLMap takes a hash mapping urls or paths to apps, and
+  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
+  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
+  #
+  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
+  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
+  # PATH_INFO.  This should be taken care of when you need to
+  # reconstruct the URL in order to create links.
+  #
+  # URLMap dispatches in such a way that the longest paths are tried
+  # first, since they are most specific.
+  class URLMap
+    def initialize(map = {})
+      remap(map)
+    end
+    def remap(map)
+      @mapping = map.map { |location, app|
+        if location =~ %r{\Ahttps?://(.*?)(/.*)}
+          host, location = $1, $2
+        else
+          host = nil
+        end
+        unless location[0] == ?/
+          raise ArgumentError, "paths need to start with /"
+        end
+        location = location.chomp('/')
+        match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
+        [host, location, match, app]
+      }.sort_by { |(h, l, _, _)| [h ? -h.size : (-1.0 / 0.0), -l.size] }  # Longest path first
+    end
+    def call(env)
+      path = env["PATH_INFO"]
+      script_name = env['SCRIPT_NAME']
+      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
+      @mapping.each { |host, location, match, app|
+        next unless (hHost == host || sName == host \
+          || (host.nil? && (hHost == sName || hHost == sName+':'+sPort)))
+        next unless path.to_s =~ match && rest = $1
+        next unless rest.empty? || rest[0] == ?/
+        env.merge!('SCRIPT_NAME' => (script_name + location), 'PATH_INFO' => rest)
+        return app.call(env)
+      }
+      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+    ensure
+      env.merge! 'PATH_INFO' => path, 'SCRIPT_NAME' => script_name
+    end
+  end
+end

data/lib/rack/utils.rb ADDED

@@ -0,0 +1,698 @@
+# -*- encoding: binary -*-
+require 'fileutils'
+require 'set'
+require 'tempfile'
+module Rack
+  # Rack::Utils contains a grab-bag of useful methods for writing web
+  # applications adopted from all kinds of Ruby libraries.
+  module Utils
+    # Performs URI escaping so that you can construct proper
+    # query strings faster.  Use this rather than the cgi.rb
+    # version since it's faster.  (Stolen from Camping).
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
+        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+    module_function :escape
+    # Unescapes a URI escaped string. (Stolen from Camping).
+    def unescape(s)
+      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+        [$1.delete('%')].pack('H*')
+      }
+    end
+    module_function :unescape
+    DEFAULT_SEP = /[&;] */n
+    # 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)
+      params = {}
+      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |x| unescape(x) }
+        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
+    end
+    module_function :parse_query
+    def parse_nested_query(qs, d = nil)
+      params = {}
+      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+        k, v = unescape(p).split('=', 2)
+        normalize_params(params, k, v)
+      end
+      return params
+    end
+    module_function :parse_nested_query
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+      return if k.empty?
+      if after == ""
+        params[k] = v
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "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 TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
+        params[k] = normalize_params(params[k], after, v)
+      end
+      return params
+    end
+    module_function :normalize_params
+    def build_query(params)
+      params.map { |k, v|
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          "#{escape(k)}=#{escape(v)}"
+        end
+      }.join("&")
+    end
+    module_function :build_query
+    def build_nested_query(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          build_nested_query(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        }.join("&")
+      when String
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{escape(value)}"
+      else
+        prefix
+      end
+    end
+    module_function :build_nested_query
+    ESCAPE_HTML = {
+      "&" => "&amp;",
+      "<" => "&lt;",
+      ">" => "&gt;",
+      "'" => "&#x27;",
+      '"' => "&quot;",
+      "/" => "&#x2F;"
+    }
+    ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
+    # Escape ampersands, brackets and quotes to their HTML/XML entities.
+    def escape_html(string)
+      string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
+    end
+    module_function :escape_html
+    def select_best_encoding(available_encodings, accept_encoding)
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+      expanded_accept_encoding =
+        accept_encoding.map { |m, q|
+          if m == "*"
+            (available_encodings - accept_encoding.map { |m2, _| m2 }).map { |m2| [m2, q] }
+          else
+            [[m, q]]
+          end
+        }.inject([]) { |mem, list|
+          mem + list
+        }
+      encoding_candidates = expanded_accept_encoding.sort_by { |_, q| -q }.map { |m, _| m }
+      unless encoding_candidates.include?("identity")
+        encoding_candidates.push("identity")
+      end
+      expanded_accept_encoding.find_all { |m, q|
+        q == 0.0
+      }.each { |m, _|
+        encoding_candidates.delete(m)
+      }
+      return (encoding_candidates & available_encodings)[0]
+    end
+    module_function :select_best_encoding
+    def set_cookie_header!(header, key, value)
+      case value
+      when Hash
+        domain  = "; domain="  + value[:domain] if value[:domain]
+        path    = "; path="    + value[:path]   if value[:path]
+        # According to RFC 2109, we need dashes here.
+        # N.B.: cgi.rb uses spaces...
+        expires = "; expires=" +
+          rfc2822(value[:expires].clone.gmtime) if value[:expires]
+        secure = "; secure"  if value[:secure]
+        httponly = "; HttpOnly" if value[:httponly]
+        value = value[:value]
+      end
+      value = [value] unless Array === value
+      cookie = escape(key) + "=" +
+        value.map { |v| escape v }.join("&") +
+        "#{domain}#{path}#{expires}#{secure}#{httponly}"
+      case header["Set-Cookie"]
+      when nil, ''
+        header["Set-Cookie"] = cookie
+      when String
+        header["Set-Cookie"] = [header["Set-Cookie"], cookie].join("\n")
+      when Array
+        header["Set-Cookie"] = (header["Set-Cookie"] + [cookie]).join("\n")
+      end
+      nil
+    end
+    module_function :set_cookie_header!
+    def delete_cookie_header!(header, key, value = {})
+      case header["Set-Cookie"]
+      when nil, ''
+        cookies = []
+      when String
+        cookies = header["Set-Cookie"].split("\n")
+      when Array
+        cookies = header["Set-Cookie"]
+      end
+      cookies.reject! { |cookie|
+        if value[:domain]
+          cookie =~ /\A#{escape(key)}=.*domain=#{value[:domain]}/
+        else
+          cookie =~ /\A#{escape(key)}=/
+        end
+      }
+      header["Set-Cookie"] = cookies.join("\n")
+      set_cookie_header!(header, key,
+                 {:value => '', :path => nil, :domain => nil,
+                   :expires => Time.at(0) }.merge(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
+    end
+    module_function :bytesize
+    # Modified version of stdlib time.rb Time#rfc2822 to use '%d-%b-%Y' instead
+    # of '% %b %Y'.
+    # It assumes that the time is in GMT to comply to the RFC 2109.
+    #
+    # NOTE: I'm not sure the RFC says it requires GMT, but is ambigous enough
+    # that I'm certain someone implemented only that option.
+    # Do not use %a and %b from Time.strptime, it would use localized names for
+    # weekday and month.
+    #
+    def rfc2822(time)
+      wday = Time::RFC2822_DAY_NAME[time.wday]
+      mon = Time::RFC2822_MONTH_NAME[time.mon - 1]
+      time.strftime("#{wday}, %d-#{mon}-%Y %H:%M:%S GMT")
+    end
+    module_function :rfc2822
+    # Parses the "Range:" header, if present, into an array of Range objects.
+    # 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)
+      # See <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35>
+      http_range = env['HTTP_RANGE']
+      return nil unless http_range
+      ranges = []
+      http_range.split(/,\s*/).each do |range_spec|
+        matches = range_spec.match(/bytes=(\d*)-(\d*)/)
+        return nil  unless matches
+        r0,r1 = matches[1], matches[2]
+        if r0.empty?
+          return nil  if r1.empty?
+          # suffix-byte-range-spec, represents trailing suffix of file
+          r0 = [size - r1.to_i, 0].max
+          r1 = size - 1
+        else
+          r0 = r0.to_i
+          if r1.empty?
+            r1 = size - 1
+          else
+            r1 = r1.to_i
+            return nil  if r1 < r0  # backwards range is syntactically invalid
+            r1 = size-1  if r1 >= size
+          end
+        end
+        ranges << (r0..r1)  if r0 <= r1
+      end
+      ranges
+    end
+    module_function :byte_ranges
+    # Context allows the use of a compatible middleware at different points
+    # in a request handling stack. A compatible middleware must define
+    # #context which should take the arguments env and app. The first of which
+    # would be the request environment. The second of which would be the rack
+    # application that the request would be forwarded to.
+    class Context
+      attr_reader :for, :app
+      def initialize(app_f, app_r)
+        raise 'running context does not respond to #context' unless app_f.respond_to? :context
+        @for, @app = app_f, app_r
+      end
+      def call(env)
+        @for.context(env, @app)
+      end
+      def recontext(app)
+        self.class.new(@for, app)
+      end
+      def context(env, app=@app)
+        recontext(app).call(env)
+      end
+    end
+    # A case-insensitive Hash that preserves the original case of a
+    # header when set.
+    class HeaderHash < Hash
+      def self.new(hash={})
+        HeaderHash === hash ? hash : super(hash)
+      end
+      def initialize(hash={})
+        super()
+        @names = {}
+        hash.each { |k, v| self[k] = v }
+      end
+      def each
+        super do |k, v|
+          yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
+        end
+      end
+      def to_hash
+        Hash[*map do |k, v|
+          [k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v]
+        end.flatten]
+      end
+      def [](k)
+        super(k) || super(@names[k.downcase])
+      end
+      def []=(k, v)
+        canonical = k.downcase
+        delete k if @names[canonical] && @names[canonical] != k # .delete is expensive, don't invoke it unless necessary
+        @names[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)
+      end
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+      def replace(other)
+        clear
+        other.each { |k, v| self[k] = v }
+        self
+      end
+    end
+    # Every standard HTTP code mapped to the appropriate message.
+    # Generated with:
+    #   curl -s http://www.iana.org/assignments/http-status-codes | \
+    #     ruby -ane 'm = /^(\d{3}) +(\S[^\[(]+)/.match($_) and
+    #                puts "      #{m[1]}  => \x27#{m[2].strip}x27,"'
+    HTTP_STATUS_CODES = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      102  => 'Processing',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      207  => 'Multi-Status',
+      226  => 'IM Used',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Found',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      306  => 'Reserved',
+      307  => 'Temporary Redirect',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Timeout',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Long',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      422  => 'Unprocessable Entity',
+      423  => 'Locked',
+      424  => 'Failed Dependency',
+      426  => 'Upgrade Required',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported',
+      506  => 'Variant Also Negotiates',
+      507  => 'Insufficient Storage',
+      510  => 'Not Extended',
+    }
+    # Responses with HTTP status codes that should not have an entity body
+    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]
+    }.flatten]
+    def status_code(status)
+      if status.is_a?(Symbol)
+        SYMBOL_TO_STATUS_CODE[status] || 500
+      else
+        status.to_i
+      end
+    end
+    module_function :status_code
+    # A multipart form data parser, adapted from IOWA.
+    #
+    # Usually, Rack::Request#POST takes care of calling this.
+    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)
+          @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 method_missing(method_name, *args, &block) #:nodoc:
+          @tempfile.__send__(method_name, *args, &block)
+        end
+      end
+      EOL = "\r\n"
+      MULTIPART_BOUNDARY = "AaB03x"
+      MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
+      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
+      def self.parse_multipart(env)
+        unless env['CONTENT_TYPE'] =~ MULTIPART
+          nil
+        else
+          boundary = "--#{$1}"
+          params = {}
+          buf = ""
+          content_length = env['CONTENT_LENGTH'].to_i
+          input = env['rack.input']
+          input.rewind
+          boundary_size = Utils.bytesize(boundary) + EOL.size
+          bufsize = 16384
+          content_length -= boundary_size
+          read_buffer = nil
+          loop do
+            read_buffer = input.gets
+            break if read_buffer == boundary + EOL
+          end
+          rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/n
+          loop {
+            head = nil
+            body = ''
+            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
+                if head =~ RFC2183
+                  filename = Hash[head.scan(DISPPARM)]['filename']
+                  filename = $1 if filename and filename =~ /^"(.*)"$/
+                elsif head =~ BROKEN_QUOTED
+                  filename = $1
+                elsif head =~ BROKEN_UNQUOTED
+                  filename = $1
+                end
+                if filename && filename !~ /\\[^\\"]/
+                  filename = Utils.unescape(filename).gsub(/\\(.)/, '\1')
+                end
+                content_type = head[MULTIPART_CONTENT_TYPE, 1]
+                name = head[MULTIPART_CONTENT_DISPOSITION, 1] || head[MULTIPART_CONTENT_ID, 1]
+                if filename
+                  body = Tempfile.new("RackMultipart")
+                  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
+              c = input.read(bufsize < content_length ? bufsize : content_length, read_buffer)
+              raise EOFError, "bad content body"  if c.nil? || c.empty?
+              buf << c
+              content_length -= c.size
+            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
+            if filename == ""
+              # filename is blank which means no file has been selected
+              data = nil
+            elsif filename
+              body.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}
+            else
+              data = body
+            end
+            Utils.normalize_params(params, name, data) unless data.nil?
+            # 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
+          }
+          input.rewind
+          params
+        end
+      end
+      def self.build_multipart(params, first = true)
+        if first
+          unless params.is_a?(Hash)
+            raise ArgumentError, "value must be a Hash"
+          end
+          multipart = false
+          query = lambda { |value|
+            case value
+            when Array
+              value.each(&query)
+            when Hash
+              value.values.each(&query)
+            when UploadedFile
+              multipart = true
+            end
+          }
+          params.values.each(&query)
+          return nil unless multipart
+        end
+        flattened_params = Hash.new
+        params.each do |key, value|
+          k = first ? key.to_s : "[#{key}]"
+          case value
+          when Array
+            value.map { |v|
+              build_multipart(v, false).each { |subkey, subvalue|
+                flattened_params["#{k}[]#{subkey}"] = subvalue
+              }
+            }
+          when Hash
+            build_multipart(value, false).each { |subkey, subvalue|
+              flattened_params[k + subkey] = subvalue
+            }
+          else
+            flattened_params[k] = value
+          end
+        end
+        if first
+          flattened_params.map { |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)
+<<-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
+#{f.read}\r
+EOF
+              end
+            else
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"\r
+\r
+#{file}\r
+EOF
+            end
+          }.join + "--#{MULTIPART_BOUNDARY}--\r"
+        else
+          flattened_params
+        end
+      end
+    end
+  end
+end