RubyGems - torquebox-console - Versions diffs - 0.2.5 → 0.3.0 - Mend

torquebox-console 0.2.5 → 0.3.0

Files changed (1091) hide show

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/showstatus.rb DELETED

@@ -1,113 +0,0 @@
-require 'erb'
-require 'rack/request'
-require 'rack/utils'
-module Rack
-  # Rack::ShowStatus catches all empty responses 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/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/static.rb DELETED

@@ -1,153 +0,0 @@
-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'
-  #
-  # Serve all requests normally from the folder "public" in the current
-  # directory but uses index.html as default route for "/"
-  #
-  #     use Rack::Static, :urls => [""], :root => 'public', :index =>
-  #     'index.html'
-  #
-  # Set custom HTTP Headers for based on rules:
-  #
-  #     use Rack::Static, :root => 'public',
-  #         :header_rules => [
-  #           [rule, {header_field => content, header_field => content}],
-  #           [rule, {header_field => content}]
-  #         ]
-  #
-  #  Rules for selecting files:
-  #
-  #  1) All files
-  #     Provide the :all symbol
-  #     :all => Matches every file
-  #
-  #  2) Folders
-  #     Provide the folder path as a string
-  #     '/folder' or '/folder/subfolder' => Matches files in a certain folder
-  #
-  #  3) File Extensions
-  #     Provide the file extensions as an array
-  #     ['css', 'js'] or %w(css js) => Matches files ending in .css or .js
-  #
-  #  4) Regular Expressions / Regexp
-  #     Provide a regular expression
-  #     %r{\.(?:css|js)\z} => Matches files ending in .css or .js
-  #     /\.(?:eot|ttf|otf|woff|svg)\z/ => Matches files ending in
-  #       the most common web font formats (.eot, .ttf, .otf, .woff, .svg)
-  #       Note: This Regexp is available as a shortcut, using the :fonts rule
-  #
-  #  5) Font Shortcut
-  #     Provide the :fonts symbol
-  #     :fonts => Uses the Regexp rule stated right above to match all common web font endings
-  #
-  #  Rule Ordering:
-  #    Rules are applied in the order that they are provided.
-  #    List rather general rules above special ones.
-  #
-  #  Complete example use case including HTTP header rules:
-  #
-  #     use Rack::Static, :root => 'public',
-  #         :header_rules => [
-  #           # Cache all static files in public caches (e.g. Rack::Cache)
-  #           #  as well as in the browser
-  #           [:all, {'Cache-Control' => 'public, max-age=31536000'}],
-  #
-  #           # Provide web fonts with cross-origin access-control-headers
-  #           #  Firefox requires this when serving assets using a Content Delivery Network
-  #           [:fonts, {'Access-Control-Allow-Origin' => '*'}]
-  #         ]
-  #
-  class Static
-    def initialize(app, options={})
-      @app = app
-      @urls = options[:urls] || ["/favicon.ico"]
-      @index = options[:index]
-      root = options[:root] || Dir.pwd
-      # HTTP Headers
-      @header_rules = options[:header_rules] || []
-      # Allow for legacy :cache_control option while prioritizing global header_rules setting
-      @header_rules.insert(0, [:all, {'Cache-Control' => options[:cache_control]}]) if options[:cache_control]
-      @headers = {}
-      @file_server = Rack::File.new(root, @headers)
-    end
-    def overwrite_file_path(path)
-      @urls.kind_of?(Hash) && @urls.key?(path) || @index && path =~ /\/$/
-    end
-    def route_file(path)
-      @urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
-    end
-    def can_serve(path)
-      route_file(path) || overwrite_file_path(path)
-    end
-    def call(env)
-      path = env["PATH_INFO"]
-      if can_serve(path)
-        env["PATH_INFO"] = (path =~ /\/$/ ? path + @index : @urls[path]) if overwrite_file_path(path)
-        @path = env["PATH_INFO"]
-        apply_header_rules
-        @file_server.call(env)
-      else
-        @app.call(env)
-      end
-    end
-    # Convert HTTP header rules to HTTP headers
-    def apply_header_rules
-      @header_rules.each do |rule, headers|
-        apply_rule(rule, headers)
-      end
-    end
-    def apply_rule(rule, headers)
-      case rule
-      when :all    # All files
-        set_headers(headers)
-      when :fonts  # Fonts Shortcut
-        set_headers(headers) if @path.match(/\.(?:ttf|otf|eot|woff|svg)\z/)
-      when String  # Folder
-        path = ::Rack::Utils.unescape(@path)
-        set_headers(headers) if (path.start_with?(rule) || path.start_with?('/' + rule))
-      when Array   # Extension/Extensions
-        extensions = rule.join('|')
-        set_headers(headers) if @path.match(/\.(#{extensions})\z/)
-      when Regexp  # Flexible Regexp
-        set_headers(headers) if @path.match(rule)
-      else
-      end
-    end
-    def set_headers(headers)
-      headers.each { |field, content| @headers[field] = content }
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/urlmap.rb DELETED

@@ -1,76 +0,0 @@
-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
-    NEGATIVE_INFINITY = -1.0 / 0.0
-    INFINITY = 1.0 / 0.0
-    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 do |(host, location, _, _)|
-        [host ? -host.size : INFINITY, -location.size]
-      end
-    end
-    def call(env)
-      path = env["PATH_INFO"]
-      script_name = env['SCRIPT_NAME']
-      hHost = env['HTTP_HOST']
-      sName = env['SERVER_NAME']
-      sPort = env['SERVER_PORT']
-      @mapping.each do |host, location, match, app|
-        unless hHost == host \
-            || sName == host \
-            || (!host && (hHost == sName || hHost == sName+':'+sPort))
-          next
-        end
-        next unless m = match.match(path.to_s)
-        rest = m[1]
-        next unless !rest || rest.empty? || rest[0] == ?/
-        env['SCRIPT_NAME'] = (script_name + location)
-        env['PATH_INFO'] = rest
-        return app.call(env)
-      end
-      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
-    ensure
-      env['PATH_INFO'] = path
-      env['SCRIPT_NAME'] = script_name
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/utils.rb DELETED

@@ -1,628 +0,0 @@
-# -*- encoding: binary -*-
-require 'fileutils'
-require 'set'
-require 'tempfile'
-require 'rack/multipart'
-require 'time'
-major, minor, patch = RUBY_VERSION.split('.').map { |v| v.to_i }
-if major == 1 && minor < 9
-  require 'rack/backports/uri/common_18'
-elsif major == 1 && minor == 9 && patch == 2 && RUBY_PATCHLEVEL <= 320 && RUBY_ENGINE != 'jruby'
-  require 'rack/backports/uri/common_192'
-elsif major == 1 && minor == 9 && patch == 3 && RUBY_PATCHLEVEL < 125
-  require 'rack/backports/uri/common_193'
-else
-  require 'uri/common'
-end
-module Rack
-  # Rack::Utils contains a grab-bag of useful methods for writing web
-  # applications adopted from all kinds of Ruby libraries.
-  module Utils
-    # URI escapes. (CGI style space to +)
-    def escape(s)
-      URI.encode_www_form_component(s)
-    end
-    module_function :escape
-    # Like URI escaping, but with %20 instead of +. Strictly speaking this is
-    # true URI escaping.
-    def escape_path(s)
-      escape(s).gsub('+', '%20')
-    end
-    module_function :escape_path
-    # Unescapes a URI escaped string with +encoding+. +encoding+ will be the
-    # target encoding of the string returned, and it defaults to UTF-8
-    if defined?(::Encoding)
-      def unescape(s, encoding = Encoding::UTF_8)
-        URI.decode_www_form_component(s, encoding)
-      end
-    else
-      def unescape(s, encoding = nil)
-        URI.decode_www_form_component(s, encoding)
-      end
-    end
-    module_function :unescape
-    DEFAULT_SEP = /[&;] */n
-    class << self
-      attr_accessor :key_space_limit
-    end
-    # The default number of bytes to allow parameter keys to take up.
-    # This helps prevent a rogue client from flooding a Request.
-    self.key_space_limit = 65536
-    # 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, &unescaper)
-      unescaper ||= method(:unescape)
-      params = KeySpaceConstrainedParams.new
-      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
-        next if p.empty?
-        k, v = p.split('=', 2).map(&unescaper)
-        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.to_params_hash
-    end
-    module_function :parse_query
-    def parse_nested_query(qs, d = nil)
-      params = KeySpaceConstrainedParams.new
-      (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
-        k, v = p.split('=', 2).map { |s| unescape(s) }
-        normalize_params(params, k, v)
-      end
-      return params.to_params_hash
-    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_hash_type?(params[k].last) && !params[k].last.key?(child_key)
-          normalize_params(params[k].last, child_key, v)
-        else
-          params[k] << normalize_params(params.class.new, child_key, v)
-        end
-      else
-        params[k] ||= params.class.new
-        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
-        params[k] = normalize_params(params[k], after, v)
-      end
-      return params
-    end
-    module_function :normalize_params
-    def params_hash_type?(obj)
-      obj.kind_of?(KeySpaceConstrainedParams) || obj.kind_of?(Hash)
-    end
-    module_function :params_hash_type?
-    def build_query(params)
-      params.map { |k, v|
-        if v.class == Array
-          build_query(v.map { |x| [k, x] })
-        else
-          v.nil? ? escape(k) : "#{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
-    def q_values(q_value_header)
-      q_value_header.to_s.split(/\s*,\s*/).map do |part|
-        value, parameters = part.split(/\s*;\s*/, 2)
-        quality = 1.0
-        if md = /\Aq=([\d.]+)/.match(parameters)
-          quality = md[1].to_f
-        end
-        [value, quality]
-      end
-    end
-    module_function :q_values
-    def best_q_match(q_value_header, available_mimes)
-      values = q_values(q_value_header)
-      values.map do |req_mime, quality|
-        match = available_mimes.first { |am| Rack::Mime.match?(am, req_mime) }
-        next unless match
-        [match, quality]
-      end.compact.sort_by do |match, quality|
-        (match.split('/', 2).count('*') * -10) + quality
-      end.last.first
-    end
-    module_function :best_q_match
-    ESCAPE_HTML = {
-      "&" => "&amp;",
-      "<" => "&lt;",
-      ">" => "&gt;",
-      "'" => "&#x27;",
-      '"' => "&quot;",
-      "/" => "&#x2F;"
-    }
-    if //.respond_to?(:encoding)
-      ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
-    else
-      # On 1.8, there is a kcode = 'u' bug that allows for XSS otherwhise
-      # TODO doesn't apply to jruby, so a better condition above might be preferable?
-      ESCAPE_HTML_PATTERN = /#{Regexp.union(*ESCAPE_HTML.keys)}/n
-    end
-    # 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]
-        max_age = "; max-age=" + value[:max_age] if value[:max_age]
-        # There is an RFC mess in the area of date formatting for Cookies. Not
-        # only are there contradicting RFCs and examples within RFC text, but
-        # there are also numerous conflicting names of fields and partially
-        # cross-applicable specifications.
-        #
-        # These are best described in RFC 2616 3.3.1. This RFC text also
-        # specifies that RFC 822 as updated by RFC 1123 is preferred. That is a
-        # fixed length format with space-date delimeted fields.
-        #
-        # See also RFC 1123 section 5.2.14.
-        #
-        # RFC 6265 also specifies "sane-cookie-date" as RFC 1123 date, defined
-        # in RFC 2616 3.3.1. RFC 6265 also gives examples that clearly denote
-        # the space delimited format. These formats are compliant with RFC 2822.
-        #
-        # For reference, all involved RFCs are:
-        # RFC 822
-        # RFC 1123
-        # RFC 2109
-        # RFC 2616
-        # RFC 2822
-        # RFC 2965
-        # RFC 6265
-        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}#{max_age}#{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]}/
-        elsif value[:path]
-          cookie =~ /\A#{escape(key)}=.*path=#{value[:path]}/
-        else
-          cookie =~ /\A#{escape(key)}=/
-        end
-      }
-      header["Set-Cookie"] = cookies.join("\n")
-      set_cookie_header!(header, key,
-                 {:value => '', :path => nil, :domain => nil,
-                   :max_age => '0',
-                   :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
-    def rfc2822(time)
-      time.rfc2822
-    end
-    module_function :rfc2822
-    # 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 rfc2109(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 :rfc2109
-    # 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 && http_range =~ /bytes=([^;]+)/
-      ranges = []
-      $1.split(/,\s*/).each do |range_spec|
-        return nil  unless range_spec =~ /(\d*)-(\d*)/
-        r0,r1 = $1, $2
-        if r0.empty?
-          return nil  if r1.empty?
-          # suffix-byte-range-spec, represents trailing suffix of file
-          r0 = size - r1.to_i
-          r0 = 0  if r0 < 0
-          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
-    # Constant time string comparison.
-    def secure_compare(a, b)
-      return false unless bytesize(a) == bytesize(b)
-      l = a.unpack("C*")
-      r, i = 0, -1
-      b.each_byte { |v| r |= v ^ l[i+=1] }
-      r == 0
-    end
-    module_function :secure_compare
-    # 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 = {}
-        each { |k,v| hash[k] = v }
-        hash
-      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
-    class KeySpaceConstrainedParams
-      def initialize(limit = Utils.key_space_limit)
-        @limit  = limit
-        @size   = 0
-        @params = {}
-      end
-      def [](key)
-        @params[key]
-      end
-      def []=(key, value)
-        @size += key.size if key && !@params.key?(key)
-        raise RangeError, 'exceeded available parameter key space' if @size > @limit
-        @params[key] = value
-      end
-      def key?(key)
-        @params.key?(key)
-      end
-      def to_params_hash
-        hash = @params
-        hash.keys.each do |key|
-          value = hash[key]
-          if value.kind_of?(self.class)
-            hash[key] = value.to_params_hash
-          elsif value.kind_of?(Array)
-            value.map! {|x| x.kind_of?(self.class) ? x.to_params_hash : x}
-          end
-        end
-        hash
-      end
-    end
-    # Every standard HTTP code mapped to the appropriate message.
-    # Generated with:
-    # irb -ropen-uri -rnokogiri
-    # > Nokogiri::XML(open("http://www.iana.org/assignments/http-status-codes/http-status-codes.xml")).css("record").each{|r|
-    #         puts "#{r.css('value').text} => '#{r.css('description').text}'"}
-    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',
-      208 => 'Already Reported',
-      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',
-      308 => 'Permanent 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',
-      425 => 'Reserved for WebDAV advanced collections expired proposal',
-      426 => 'Upgrade Required',
-      427 => 'Unassigned',
-      428 => 'Precondition Required',
-      429 => 'Too Many Requests',
-      430 => 'Unassigned',
-      431 => 'Request Header Fields Too Large',
-      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 (Experimental)',
-      507 => 'Insufficient Storage',
-      508 => 'Loop Detected',
-      509 => 'Unassigned',
-      510 => 'Not Extended',
-      511 => 'Network Authentication Required'
-    }
-    # Responses with HTTP status codes that should not have an entity body
-    STATUS_WITH_NO_ENTITY_BODY = Set.new((100..199).to_a << 204 << 205 << 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
-    Multipart = Rack::Multipart
-  end
-end