second_step 0.1.2 → 0.1.3

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/rack-2.0.1/lib/rack/multipart/uploaded_file.rb

@@ -1,33 +0,0 @@
-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)], encoding: Encoding::BINARY)
-        @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/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/rack-2.0.1/lib/rack/null_logger.rb

@@ -1,37 +0,0 @@
-module Rack
-  class NullLogger
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      env[RACK_LOGGER] = self
-      @app.call(env)
-    end
-
-    def info(progname = nil, &block); end
-    def debug(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/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/rack-2.0.1/lib/rack/query_parser.rb

@@ -1,192 +0,0 @@
-module Rack
-  class QueryParser
-    DEFAULT_SEP = /[&;] */n
-    COMMON_SEP = { ";" => /[;] */n, ";," => /[;,] */n, "&" => /[&] */n }
-
-    # ParameterTypeError is the error that is raised when incoming structural
-    # parameters (parsed by parse_nested_query) contain conflicting types.
-    class ParameterTypeError < TypeError; end
-
-    # InvalidParameterError is the error that is raised when incoming structural
-    # parameters (parsed by parse_nested_query) contain invalid format or byte
-    # sequence.
-    class InvalidParameterError < ArgumentError; end
-
-    def self.make_default(key_space_limit, param_depth_limit)
-      new Params, key_space_limit, param_depth_limit
-    end
-
-    attr_reader :key_space_limit, :param_depth_limit
-
-    def initialize(params_class, key_space_limit, param_depth_limit)
-      @params_class = params_class
-      @key_space_limit = key_space_limit
-      @param_depth_limit = param_depth_limit
-    end
-
-    # 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 = make_params
-
-      (qs || '').split(d ? (COMMON_SEP[d] || /[#{d}] */n) : DEFAULT_SEP).each do |p|
-        next if p.empty?
-        k, v = p.split('='.freeze, 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
-
-    # parse_nested_query expands a query string into structural types. Supported
-    # types are Arrays, Hashes and basic value types. It is possible to supply
-    # query strings with parameters of conflicting types, in this case a
-    # ParameterTypeError is raised. Users are encouraged to return a 400 in this
-    # case.
-    def parse_nested_query(qs, d = nil)
-      return {} if qs.nil? || qs.empty?
-      params = make_params
-
-      (qs || '').split(d ? (COMMON_SEP[d] || /[#{d}] */n) : DEFAULT_SEP).each do |p|
-        k, v = p.split('='.freeze, 2).map! { |s| unescape(s) }
-
-        normalize_params(params, k, v, param_depth_limit)
-      end
-
-      return params.to_params_hash
-    rescue ArgumentError => e
-      raise InvalidParameterError, e.message
-    end
-
-    # normalize_params recursively expands parameters into structural types. If
-    # the structural types represented by two different parameter names are in
-    # conflict, a ParameterTypeError is raised.
-    def normalize_params(params, name, v, depth)
-      raise RangeError if depth <= 0
-
-      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
-      k = $1 || ''.freeze
-      after = $' || ''.freeze
-
-      if k.empty?
-        if !v.nil? && name == "[]".freeze
-          return Array(v)
-        else
-          return
-        end
-      end
-
-      if after == ''.freeze
-        params[k] = v
-      elsif after == "[".freeze
-        params[name] = v
-      elsif after == "[]".freeze
-        params[k] ||= []
-        raise ParameterTypeError, "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 ParameterTypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        if params_hash_type?(params[k].last) && !params_hash_has_key?(params[k].last, child_key)
-          normalize_params(params[k].last, child_key, v, depth - 1)
-        else
-          params[k] << normalize_params(make_params, child_key, v, depth - 1)
-        end
-      else
-        params[k] ||= make_params
-        raise ParameterTypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params_hash_type?(params[k])
-        params[k] = normalize_params(params[k], after, v, depth - 1)
-      end
-
-      params
-    end
-
-    def make_params
-      @params_class.new @key_space_limit
-    end
-
-    def new_space_limit(key_space_limit)
-      self.class.new @params_class, key_space_limit, param_depth_limit
-    end
-
-    def new_depth_limit(param_depth_limit)
-      self.class.new @params_class, key_space_limit, param_depth_limit
-    end
-
-    private
-
-    def params_hash_type?(obj)
-      obj.kind_of?(@params_class)
-    end
-
-    def params_hash_has_key?(hash, key)
-      return false if key =~ /\[\]/
-
-      key.split(/[\[\]]+/).inject(hash) do |h, part|
-        next h if part == ''
-        return false unless params_hash_type?(h) && h.key?(part)
-        h[part]
-      end
-
-      true
-    end
-
-    def unescape(s)
-      Utils.unescape(s)
-    end
-
-    class Params
-      def initialize(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)
-            if value.object_id == self.object_id
-              hash[key] = hash
-            else
-              hash[key] = value.to_params_hash
-            end
-          elsif value.kind_of?(Array)
-            value.map! {|x| x.kind_of?(self.class) ? x.to_params_hash : x}
-          end
-        end
-        hash
-      end
-    end
-  end
-end

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/rack-2.0.1/lib/rack/recursive.rb

@@ -1,62 +0,0 @@
-require 'uri'
-
-module Rack
-  # Rack::ForwardRequest gets caught by Rack::Recursive and redirects
-  # the current request to the app at +url+.
-  #
-  #   raise ForwardRequest.new("/not-found")
-  #
-
-  class ForwardRequest < Exception
-    attr_reader :url, :env
-
-    def initialize(url, env={})
-      @url = URI(url)
-      @env = env
-
-      @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
-
-      super "forwarding to #{url}"
-    end
-  end
-
-  # Rack::Recursive allows applications called down the chain to
-  # include data from other applications (by using
-  # <tt>rack['rack.recursive.include'][...]</tt> or raise a
-  # ForwardRequest to redirect internally.
-
-  class Recursive
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      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))
-    end
-
-    def include(env, path)
-      unless path.index(@script_name) == 0 && (path[@script_name.size] == ?/ ||
-                                               path[@script_name.size].nil?)
-        raise ArgumentError, "can only include below #{@script_name}, not #{path}"
-      end
-
-      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)
-    end
-  end
-end

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/rack-2.0.1/lib/rack/reloader.rb

@@ -1,110 +0,0 @@
-#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
-#       Rack::Reloader is subject to the terms of an MIT-style license.
-#      See COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-require 'pathname'
-
-module Rack
-
-  # High performant source reloader
-  #
-  # This class acts as Rack middleware.
-  #
-  # What makes it especially suited for use in a production environment is that
-  # any file will only be checked once and there will only be made one system
-  # call stat(2).
-  #
-  # Please note that this will not reload files in the background, it does so
-  # only when actively called.
-  #
-  # It is performing a check/reload cycle at the start of every request, but
-  # also respects a cool down time, during which nothing will be done.
-  class Reloader
-    def initialize(app, cooldown = 10, backend = Stat)
-      @app = app
-      @cooldown = cooldown
-      @last = (Time.now - cooldown)
-      @cache = {}
-      @mtimes = {}
-      @reload_mutex = Mutex.new
-
-      extend backend
-    end
-
-    def call(env)
-      if @cooldown and Time.now > @last + @cooldown
-        if Thread.list.size > 1
-          @reload_mutex.synchronize{ reload! }
-        else
-          reload!
-        end
-
-        @last = Time.now
-      end
-
-      @app.call(env)
-    end
-
-    def reload!(stderr = $stderr)
-      rotation do |file, mtime|
-        previous_mtime = @mtimes[file] ||= mtime
-        safe_load(file, mtime, stderr) if mtime > previous_mtime
-      end
-    end
-
-    # A safe Kernel::load, issuing the hooks depending on the results
-    def safe_load(file, mtime, stderr = $stderr)
-      load(file)
-      stderr.puts "#{self.class}: reloaded `#{file}'"
-      file
-    rescue LoadError, SyntaxError => ex
-      stderr.puts ex
-    ensure
-      @mtimes[file] = mtime
-    end
-
-    module Stat
-      def rotation
-        files = [$0, *$LOADED_FEATURES].uniq
-        paths = ['./', *$LOAD_PATH].uniq
-
-        files.map{|file|
-          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
-
-          found, stat = figure_path(file, paths)
-          next unless found && stat && mtime = stat.mtime
-
-          @cache[file] = found
-
-          yield(found, mtime)
-        }.compact
-      end
-
-      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
-      # the +file+ might reside in. Returns the full path and File::Stat for the
-      # path.
-      def figure_path(file, paths)
-        found = @cache[file]
-        found = file if !found and Pathname.new(file).absolute?
-        found, stat = safe_stat(found)
-        return found, stat if found
-
-        paths.find do |possible_path|
-          path = ::File.join(possible_path, file)
-          found, stat = safe_stat(path)
-          return ::File.expand_path(found), stat if found
-        end
-
-        return false, false
-      end
-
-      def safe_stat(file)
-        return unless file
-        stat = ::File.stat(file)
-        return file, stat if stat.file?
-      rescue Errno::ENOENT, Errno::ENOTDIR, Errno::ESRCH
-        @cache.delete(file) and false
-      end
-    end
-  end
-end

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/rack-2.0.1/lib/rack/request.rb

@@ -1,487 +0,0 @@
-require 'rack/utils'
-require 'rack/media_type'
-
-module Rack
-  # Rack::Request provides a convenient interface to a Rack
-  # environment.  It is stateless, the environment +env+ passed to the
-  # constructor will be directly modified.
-  #
-  #   req = Rack::Request.new(env)
-  #   req.post?
-  #   req.params["data"]
-
-  class Request
-    def initialize(env)
-      @params = nil
-      super(env)
-    end
-
-    def params
-      @params ||= super
-    end
-
-    def update_param(k, v)
-      super
-      @params = nil
-    end
-
-    def delete_param(k)
-      v = super
-      @params = nil
-      v
-    end
-
-    module Env
-      # The environment of the request.
-      attr_reader :env
-
-      def initialize(env)
-        @env = env
-        super()
-      end
-
-      # Predicate method to test to see if `name` has been set as request
-      # specific data
-      def has_header?(name)
-        @env.key? name
-      end
-
-      # Get a request specific value for `name`.
-      def get_header(name)
-        @env[name]
-      end
-
-      # If a block is given, it yields to the block if the value hasn't been set
-      # on the request.
-      def fetch_header(name, &block)
-        @env.fetch(name, &block)
-      end
-
-      # Loops through each key / value pair in the request specific data.
-      def each_header(&block)
-        @env.each(&block)
-      end
-
-      # Set a request specific value for `name` to `v`
-      def set_header(name, v)
-        @env[name] = v
-      end
-
-      # Add a header that may have multiple values.
-      #
-      # Example:
-      #   request.add_header 'Accept', 'image/png'
-      #   request.add_header 'Accept', '*/*'
-      #
-      #   assert_equal 'image/png,*/*', request.get_header('Accept')
-      #
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
-      def add_header key, v
-        if v.nil?
-          get_header key
-        elsif has_header? key
-          set_header key, "#{get_header key},#{v}"
-        else
-          set_header key, v
-        end
-      end
-
-      # Delete a request specific value for `name`.
-      def delete_header(name)
-        @env.delete name
-      end
-
-      def initialize_copy(other)
-        @env = other.env.dup
-      end
-    end
-
-    module Helpers
-      # The set of form-data media-types. Requests that do not indicate
-      # one of the media types presents in this list will not be eligible
-      # for form-data / param parsing.
-      FORM_DATA_MEDIA_TYPES = [
-        'application/x-www-form-urlencoded',
-        'multipart/form-data'
-      ]
-
-      # The set of media-types. Requests that do not indicate
-      # one of the media types presents in this list will not be eligible
-      # for param parsing like soap attachments or generic multiparts
-      PARSEABLE_DATA_MEDIA_TYPES = [
-        'multipart/related',
-        'multipart/mixed'
-      ]
-
-      # Default ports depending on scheme. Used to decide whether or not
-      # to include the port in a generated URI.
-      DEFAULT_PORTS = { 'http' => 80, 'https' => 443, 'coffee' => 80 }
-
-      HTTP_X_FORWARDED_SCHEME = 'HTTP_X_FORWARDED_SCHEME'.freeze
-      HTTP_X_FORWARDED_PROTO  = 'HTTP_X_FORWARDED_PROTO'.freeze
-      HTTP_X_FORWARDED_HOST   = 'HTTP_X_FORWARDED_HOST'.freeze
-      HTTP_X_FORWARDED_PORT   = 'HTTP_X_FORWARDED_PORT'.freeze
-      HTTP_X_FORWARDED_SSL    = 'HTTP_X_FORWARDED_SSL'.freeze
-
-      def body;            get_header(RACK_INPUT)                         end
-      def script_name;     get_header(SCRIPT_NAME).to_s                   end
-      def script_name=(s); set_header(SCRIPT_NAME, s.to_s)                end
-
-      def path_info;       get_header(PATH_INFO).to_s                     end
-      def path_info=(s);   set_header(PATH_INFO, s.to_s)                  end
-
-      def request_method;  get_header(REQUEST_METHOD)                     end
-      def query_string;    get_header(QUERY_STRING).to_s                  end
-      def content_length;  get_header('CONTENT_LENGTH')                   end
-      def logger;          get_header(RACK_LOGGER)                        end
-      def user_agent;      get_header('HTTP_USER_AGENT')                  end
-      def multithread?;    get_header(RACK_MULTITHREAD)                   end
-
-      # the referer of the client
-      def referer;         get_header('HTTP_REFERER')                     end
-      alias referrer referer
-
-      def session
-        fetch_header(RACK_SESSION) do |k|
-          set_header RACK_SESSION, default_session
-        end
-      end
-
-      def session_options
-        fetch_header(RACK_SESSION_OPTIONS) do |k|
-          set_header RACK_SESSION_OPTIONS, {}
-        end
-      end
-
-      # Checks the HTTP request method (or verb) to see if it was of type DELETE
-      def delete?;  request_method == DELETE  end
-
-      # Checks the HTTP request method (or verb) to see if it was of type GET
-      def get?;     request_method == GET       end
-
-      # Checks the HTTP request method (or verb) to see if it was of type HEAD
-      def head?;    request_method == HEAD      end
-
-      # Checks the HTTP request method (or verb) to see if it was of type OPTIONS
-      def options?; request_method == OPTIONS end
-
-      # Checks the HTTP request method (or verb) to see if it was of type LINK
-      def link?;    request_method == LINK    end
-
-      # Checks the HTTP request method (or verb) to see if it was of type PATCH
-      def patch?;   request_method == PATCH   end
-
-      # Checks the HTTP request method (or verb) to see if it was of type POST
-      def post?;    request_method == POST    end
-
-      # Checks the HTTP request method (or verb) to see if it was of type PUT
-      def put?;     request_method == PUT     end
-
-      # Checks the HTTP request method (or verb) to see if it was of type TRACE
-      def trace?;   request_method == TRACE   end
-
-      # Checks the HTTP request method (or verb) to see if it was of type UNLINK
-      def unlink?;  request_method == UNLINK  end
-
-      def scheme
-        if get_header(HTTPS) == 'on'
-          'https'
-        elsif get_header(HTTP_X_FORWARDED_SSL) == 'on'
-          'https'
-        elsif get_header(HTTP_X_FORWARDED_SCHEME)
-          get_header(HTTP_X_FORWARDED_SCHEME)
-        elsif get_header(HTTP_X_FORWARDED_PROTO)
-          get_header(HTTP_X_FORWARDED_PROTO).split(',')[0]
-        else
-          get_header(RACK_URL_SCHEME)
-        end
-      end
-
-      def authority
-        get_header(SERVER_NAME) + ':' + get_header(SERVER_PORT)
-      end
-
-      def cookies
-        hash = fetch_header(RACK_REQUEST_COOKIE_HASH) do |k|
-          set_header(k, {})
-        end
-        string = get_header HTTP_COOKIE
-
-        return hash if string == get_header(RACK_REQUEST_COOKIE_STRING)
-        hash.replace Utils.parse_cookies_header get_header HTTP_COOKIE
-        set_header(RACK_REQUEST_COOKIE_STRING, string)
-        hash
-      end
-
-      def content_type
-        content_type = get_header('CONTENT_TYPE')
-        content_type.nil? || content_type.empty? ? nil : content_type
-      end
-
-      def xhr?
-        get_header("HTTP_X_REQUESTED_WITH") == "XMLHttpRequest"
-      end
-
-      def host_with_port
-        if forwarded = get_header(HTTP_X_FORWARDED_HOST)
-          forwarded.split(/,\s?/).last
-        else
-          get_header(HTTP_HOST) || "#{get_header(SERVER_NAME) || get_header(SERVER_ADDR)}:#{get_header(SERVER_PORT)}"
-        end
-      end
-
-      def host
-        # Remove port number.
-        host_with_port.to_s.sub(/:\d+\z/, '')
-      end
-
-      def port
-        if port = host_with_port.split(/:/)[1]
-          port.to_i
-        elsif port = get_header(HTTP_X_FORWARDED_PORT)
-          port.to_i
-        elsif has_header?(HTTP_X_FORWARDED_HOST)
-          DEFAULT_PORTS[scheme]
-        elsif has_header?(HTTP_X_FORWARDED_PROTO)
-          DEFAULT_PORTS[get_header(HTTP_X_FORWARDED_PROTO).split(',')[0]]
-        else
-          get_header(SERVER_PORT).to_i
-        end
-      end
-
-      def ssl?
-        scheme == 'https'
-      end
-
-      def ip
-        remote_addrs = split_ip_addresses(get_header('REMOTE_ADDR'))
-        remote_addrs = reject_trusted_ip_addresses(remote_addrs)
-
-        return remote_addrs.first if remote_addrs.any?
-
-        forwarded_ips = split_ip_addresses(get_header('HTTP_X_FORWARDED_FOR'))
-
-        return reject_trusted_ip_addresses(forwarded_ips).last || get_header("REMOTE_ADDR")
-      end
-
-      # The media type (type/subtype) portion of the CONTENT_TYPE header
-      # without any media type parameters. e.g., when CONTENT_TYPE is
-      # "text/plain;charset=utf-8", the media-type is "text/plain".
-      #
-      # For more information on the use of media types in HTTP, see:
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
-      def media_type
-        MediaType.type(content_type)
-      end
-
-      # The media type parameters provided in CONTENT_TYPE as a Hash, or
-      # an empty Hash if no CONTENT_TYPE or media-type parameters were
-      # provided.  e.g., when the CONTENT_TYPE is "text/plain;charset=utf-8",
-      # this method responds with the following Hash:
-      #   { 'charset' => 'utf-8' }
-      def media_type_params
-        MediaType.params(content_type)
-      end
-
-      # The character set of the request body if a "charset" media type
-      # parameter was given, or nil if no "charset" was specified. Note
-      # that, per RFC2616, text/* media types that specify no explicit
-      # charset are to be considered ISO-8859-1.
-      def content_charset
-        media_type_params['charset']
-      end
-
-      # Determine whether the request body contains form-data by checking
-      # the request Content-Type for one of the media-types:
-      # "application/x-www-form-urlencoded" or "multipart/form-data". The
-      # list of form-data media types can be modified through the
-      # +FORM_DATA_MEDIA_TYPES+ array.
-      #
-      # A request body is also assumed to contain form-data when no
-      # Content-Type header is provided and the request_method is POST.
-      def form_data?
-        type = media_type
-        meth = get_header(RACK_METHODOVERRIDE_ORIGINAL_METHOD) || get_header(REQUEST_METHOD)
-        (meth == POST && type.nil?) || FORM_DATA_MEDIA_TYPES.include?(type)
-      end
-
-      # Determine whether the request body contains data by checking
-      # the request media_type against registered parse-data media-types
-      def parseable_data?
-        PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
-      end
-
-      # Returns the data received in the query string.
-      def GET
-        if get_header(RACK_REQUEST_QUERY_STRING) == query_string
-          get_header(RACK_REQUEST_QUERY_HASH)
-        else
-          query_hash = parse_query(query_string, '&;')
-          set_header(RACK_REQUEST_QUERY_STRING, query_string)
-          set_header(RACK_REQUEST_QUERY_HASH, query_hash)
-        end
-      end
-
-      # Returns the data received in the request body.
-      #
-      # This method support both application/x-www-form-urlencoded and
-      # multipart/form-data.
-      def POST
-        if get_header(RACK_INPUT).nil?
-          raise "Missing rack.input"
-        elsif get_header(RACK_REQUEST_FORM_INPUT) == get_header(RACK_INPUT)
-          get_header(RACK_REQUEST_FORM_HASH)
-        elsif form_data? || parseable_data?
-          unless set_header(RACK_REQUEST_FORM_HASH, parse_multipart)
-            form_vars = get_header(RACK_INPUT).read
-
-            # Fix for Safari Ajax postings that always append \0
-            # form_vars.sub!(/\0\z/, '') # performance replacement:
-            form_vars.slice!(-1) if form_vars[-1] == ?\0
-
-            set_header RACK_REQUEST_FORM_VARS, form_vars
-            set_header RACK_REQUEST_FORM_HASH, parse_query(form_vars, '&')
-
-            get_header(RACK_INPUT).rewind
-          end
-          set_header RACK_REQUEST_FORM_INPUT, get_header(RACK_INPUT)
-          get_header RACK_REQUEST_FORM_HASH
-        else
-          {}
-        end
-      end
-
-      # The union of GET and POST data.
-      #
-      # Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.
-      def params
-        self.GET.merge(self.POST)
-      rescue EOFError
-        self.GET.dup
-      end
-
-      # Destructively update a parameter, whether it's in GET and/or POST. Returns nil.
-      #
-      # The parameter is updated wherever it was previous defined, so GET, POST, or both. If it wasn't previously defined, it's inserted into GET.
-      #
-      # <tt>env['rack.input']</tt> is not touched.
-      def update_param(k, v)
-        found = false
-        if self.GET.has_key?(k)
-          found = true
-          self.GET[k] = v
-        end
-        if self.POST.has_key?(k)
-          found = true
-          self.POST[k] = v
-        end
-        unless found
-          self.GET[k] = v
-        end
-      end
-
-      # Destructively delete a parameter, whether it's in GET or POST. Returns the value of the deleted parameter.
-      #
-      # If the parameter is in both GET and POST, the POST value takes precedence since that's how #params works.
-      #
-      # <tt>env['rack.input']</tt> is not touched.
-      def delete_param(k)
-        [ self.POST.delete(k), self.GET.delete(k) ].compact.first
-      end
-
-      def base_url
-        url = "#{scheme}://#{host}"
-        url << ":#{port}" if port != DEFAULT_PORTS[scheme]
-        url
-      end
-
-      # Tries to return a remake of the original request URL as a string.
-      def url
-        base_url + fullpath
-      end
-
-      def path
-        script_name + path_info
-      end
-
-      def fullpath
-        query_string.empty? ? path : "#{path}?#{query_string}"
-      end
-
-      def accept_encoding
-        parse_http_accept_header(get_header("HTTP_ACCEPT_ENCODING"))
-      end
-
-      def accept_language
-        parse_http_accept_header(get_header("HTTP_ACCEPT_LANGUAGE"))
-      end
-
-      def trusted_proxy?(ip)
-        ip =~ /\A127\.0\.0\.1\Z|\A(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|\A::1\Z|\Afd[0-9a-f]{2}:.+|\Alocalhost\Z|\Aunix\Z|\Aunix:/i
-      end
-
-      # shortcut for <tt>request.params[key]</tt>
-      def [](key)
-        if $verbose
-          warn("Request#[] is deprecated and will be removed in a future version of Rack. Please use request.params[] instead")
-        end
-
-        params[key.to_s]
-      end
-
-      # shortcut for <tt>request.params[key] = value</tt>
-      #
-      # Note that modifications will not be persisted in the env. Use update_param or delete_param if you want to destructively modify params.
-      def []=(key, value)
-        if $verbose
-          warn("Request#[]= is deprecated and will be removed in a future version of Rack. Please use request.params[]= instead")
-        end
-
-        params[key.to_s] = value
-      end
-
-      # like Hash#values_at
-      def values_at(*keys)
-        keys.map { |key| params[key] }
-      end
-
-      private
-
-      def default_session; {}; end
-
-      def parse_http_accept_header(header)
-        header.to_s.split(/\s*,\s*/).map do |part|
-          attribute, parameters = part.split(/\s*;\s*/, 2)
-          quality = 1.0
-          if parameters and /\Aq=([\d.]+)/ =~ parameters
-            quality = $1.to_f
-          end
-          [attribute, quality]
-        end
-      end
-
-      def query_parser
-        Utils.default_query_parser
-      end
-
-      def parse_query(qs, d='&')
-        query_parser.parse_nested_query(qs, d)
-      end
-
-      def parse_multipart
-        Rack::Multipart.extract_multipart(self, query_parser)
-      end
-
-      def split_ip_addresses(ip_addresses)
-        ip_addresses ? ip_addresses.strip.split(/[,\s]+/) : []
-      end
-
-      def reject_trusted_ip_addresses(ip_addresses)
-        ip_addresses.reject { |ip| trusted_proxy?(ip) }
-      end
-    end
-
-    include Env
-    include Helpers
-  end
-end