rackup 0.2.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23caa71b03397adf9344168de947fca289d1e4df6c577678e8b7fc8285c522e9
-  data.tar.gz: e39027a50a3f54eb0928d6cef394f79cdd52c71da06854f2fcf5ba3a5722c083
+  metadata.gz: 92bf342afdd0c82df66b17a4d0a18102b82ff4f6fe0d6c0a9c6c448c1833b020
+  data.tar.gz: '0803347f74697ae828f519c5ec3bb3c9d52aa67605c1cc86c918e460ef3b2f22'
 SHA512:
-  metadata.gz: be73868bc8995d73ae90f9e70bc6b8141ff5b0c26276cfcb8c010376cf3b7bdfc97d3836afad0524de61cee8c9cb910f16806becae671569fbb3484702c84e6c
-  data.tar.gz: fdad77f1c5b70d027c67a893db852bb825631772854df4bfdfc08d3d5ab2a2c40212375bc318f276695ce659014b7f72a2c80d62b0c0c73a0f6069649f21c845
+  metadata.gz: ccc75df436ba2fba6a7971d0eb0db09714cf90364eeca96d380f3cc86b57845e5d4c38fb1bb9d91cce47207656926de42ebec03d2688dad292fc00c48f76dcf0
+  data.tar.gz: 074af927d0ed8d981ad74d02139e7493269d6406b3426675aab136d051e4d93e7355f98ca5ae4081458e35572efa8360db47fe657e6dce6ab57a7cf711bae626

data/lib/rackup/version.rb

@@ -1,25 +1,8 @@
 # frozen_string_literal: true
 
-# Copyright, 2022, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# Released under the MIT License.
+# Copyright, 2022, by Samuel Williams.
 
 module Rackup
-  VERSION = "0.2.3"
+  VERSION = "1.0.0"
 end

data/lib/rackup.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2022, by Samuel Williams.
+
 require_relative 'rackup/handler'
 require_relative 'rackup/server'
 require_relative 'rackup/version'
 
 require_relative 'rackup/handler/webrick'
-require_relative 'rackup/handler/cgi'
+require_relative 'rackup/handler/cgi'

data/{LICENSE.md → license.md}

@@ -1,7 +1,7 @@
-Released under the MIT license.
+# MIT License
 
-Copyright, 2007-2021, by [Leah Neukirchen](https://leahneukirchen.org).  
-Copyright, 2022, by [Samuel G. D. Williams](https://www.codeotaku.com).  
+Copyright, 2022, by Samuel Williams.  
+Copyright, 2022, by Jeremy Evans.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -10,13 +10,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,31 @@
+# Rackup
+
+`rackup` provides a command line interface for running a Rack-compatible application.
+
+[![Development Status](https://github.com/rack/rackup/workflows/Test/badge.svg)](https://github.com/rack/rackup/actions?workflow=Test)
+
+## Installation
+
+``` bash
+$ gem install rackup
+```
+
+## Usage
+
+In a directory with your `config.ru` simply run the command:
+
+``` bash
+$ rackup
+```
+
+Your application should now be available locally, typically `http://localhost:9292`.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.

data/security.md

@@ -0,0 +1,3 @@
+# Security Policy
+
+Please see our main security policy: https://github.com/rack/rack/security/policy

metadata

@@ -1,29 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: rackup
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 1.0.0
 platform: ruby
 authors:
-- Rack Contributors
+- Samuel Williams
+- Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-11 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.0.beta1
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.0.beta1
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: webrick
   requirement: !ruby/object:Gem::Requirement
@@ -39,33 +40,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-sprint
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: minitest-global_expectations
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +82,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: minitest-sprint
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -110,22 +111,15 @@ dependencies:
         version: '0'
 description:
 email:
-executables:
-- rackup
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE.md
-- bin/rackup
-- lib/rack/handler.rb
-- lib/rack/server.rb
 - lib/rackup.rb
-- lib/rackup/handler.rb
-- lib/rackup/handler/cgi.rb
-- lib/rackup/handler/webrick.rb
-- lib/rackup/lobster.rb
-- lib/rackup/server.rb
 - lib/rackup/version.rb
+- license.md
+- readme.md
+- security.md
 homepage: https://github.com/rack/rackup
 licenses:
 - MIT
@@ -145,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: A general server command for Rack applications.

data/bin/rackup

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require_relative "../lib/rackup"
-Rackup::Server.start

data/lib/rack/handler.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-warn "Rack::Handler is deprecated and replaced by Rackup::Handler"
-require_relative '../rackup/handler'
-module Rack
-	Handler = ::Rackup::Handler
-end

data/lib/rack/server.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-warn "Rack::Server is deprecated and replaced by Rackup::Server"
-require_relative '../rackup/server'
-module Rack
-	Server = ::Rackup::Server
-end

data/lib/rackup/handler/cgi.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Rackup
-  module Handler
-    class CGI
-      include Rack
-
-      def self.run(app, **options)
-        $stdin.binmode
-        serve app
-      end
-
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
-
-        env.update(
-          RACK_INPUT        => $stdin,
-          RACK_ERRORS       => $stderr,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[REQUEST_PATH] ||= "/"
-
-        status, headers, body = app.call(env)
-        begin
-          send_headers status, headers
-          send_body body
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-
-      def self.send_headers(status, headers)
-        $stdout.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            $stdout.print "#{k}: #{v}\r\n"
-          }
-        }
-        $stdout.print "\r\n"
-        $stdout.flush
-      end
-
-      def self.send_body(body)
-        body.each { |part|
-          $stdout.print part
-          $stdout.flush
-        }
-      end
-    end
-
-    register :cgi, CGI
-  end
-end

data/lib/rackup/handler/webrick.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require 'webrick'
-require 'stringio'
-
-require 'rack/constants'
-require_relative '../handler'
-require_relative '../version'
-
-# This monkey patch allows for applications to perform their own chunking
-# through WEBrick::HTTPResponse if rack is set to true.
-class WEBrick::HTTPResponse
-  attr_accessor :rack
-
-  alias _rack_setup_header setup_header
-  def setup_header
-    app_chunking = rack && @header['transfer-encoding'] == 'chunked'
-
-    @chunked = app_chunking if app_chunking
-
-    _rack_setup_header
-
-    @chunked = false if app_chunking
-  end
-end
-
-module Rackup
-  module Handler
-    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
-      include Rack
-      
-      def self.run(app, **options)
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : nil
-
-        if !options[:BindAddress] || options[:Host]
-          options[:BindAddress] = options.delete(:Host) || default_host
-        end
-        options[:Port] ||= 8080
-        if options[:SSLEnable]
-          require 'webrick/https'
-        end
-
-        @server = ::WEBrick::HTTPServer.new(options)
-        @server.mount "/", Rackup::Handler::WEBrick, app
-        yield @server if block_given?
-        @server.start
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-
-      def self.shutdown
-        if @server
-          @server.shutdown
-          @server = nil
-        end
-      end
-
-      def initialize(server, app)
-        super server
-        @app = app
-      end
-
-      def service(req, res)
-        res.rack = true
-        env = req.meta_vars
-        env.delete_if { |k, v| v.nil? }
-
-        rack_input = StringIO.new(req.body.to_s)
-        rack_input.set_encoding(Encoding::BINARY)
-
-        env.update(
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http",
-          RACK_IS_HIJACK    => true,
-        )
-
-        env[QUERY_STRING] ||= ""
-        unless env[PATH_INFO] == ""
-          path, n = req.request_uri.path, env[SCRIPT_NAME].length
-          env[PATH_INFO] = path[n, path.length - n]
-        end
-        env[REQUEST_PATH] ||= [env[SCRIPT_NAME], env[PATH_INFO]].join
-
-        status, headers, body = @app.call(env)
-        begin
-          res.status = status
-
-          if value = headers[RACK_HIJACK]
-            io_lambda = value
-          elsif !body.respond_to?(:to_path) && !body.respond_to?(:each)
-            io_lambda = body
-          end
-
-          if value = headers.delete('set-cookie')
-            res.cookies.concat(Array(value))
-          end
-
-          headers.each { |key, value|
-            # Skip keys starting with rack., per Rack SPEC
-            next if key.start_with?('rack.')
-
-            # Since WEBrick won't accept repeated headers,
-            # merge the values per RFC 1945 section 4.2.
-            value = value.join(", ") if Array === value
-            res[key] = value
-          }
-
-          if io_lambda
-            rd, wr = IO.pipe
-            res.body = rd
-            res.chunked = true
-            io_lambda.call wr
-          elsif body.respond_to?(:to_path)
-            res.body = ::File.open(body.to_path, 'rb')
-          else
-            body.each { |part|
-              res.body << part
-            }
-          end
-        ensure
-          body.close if body.respond_to? :close
-        end
-      end
-    end
-
-    register :webrick, WEBrick
-  end
-end

data/lib/rackup/handler.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Rackup
-  # *Handlers* connect web servers with Rack.
-  #
-  # Rackup includes Handlers for WEBrick and CGI.
-  #
-  # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
-  # A second optional hash can be passed to include server-specific
-  # configuration.
-  module Handler
-    @handlers = {}
-
-    # Register a named handler class.
-    def self.register(name, klass)
-      if klass.is_a?(String)
-        warn "Calling Rackup::Handler.register with a string is deprecated, use the class/module itself.", uplevel: 1
-
-        klass = self.const_get(klass, false)
-      end
-
-      name = name.to_sym
-
-      @handlers[name] = klass
-    end
-
-    def self.[](name)
-      name = name.to_sym
-
-      begin
-        @handlers[name] || self.const_get(name, false)
-      rescue NameError
-        # Ignore.
-      end
-    end
-
-    def self.get(name)
-      return nil unless name
-
-      name = name.to_sym
-
-      if server = self[name]
-        return server
-      end
-
-      begin
-        require_handler("rackup/handler", name)
-      rescue LoadError
-        require_handler("rack/handler", name)
-      end
-
-      return self[name]
-    end
-
-    RACK_HANDLER = 'RACK_HANDLER'
-    RACKUP_HANDLER = 'RACKUP_HANDLER'
-
-    SERVER_NAMES = %i(puma falcon webrick).freeze
-    private_constant :SERVER_NAMES
-
-    # Select first available Rack handler given an `Array` of server names.
-    # Raises `LoadError` if no handler was found.
-    #
-    #   > pick ['puma', 'webrick']
-    #   => Rackup::Handler::WEBrick
-    def self.pick(server_names)
-      server_names = Array(server_names)
-
-      server_names.each do |server_name|
-        begin
-          server = self.get(server_name)
-         return server if server
-        rescue LoadError
-          # Ignore.
-        end
-      end
-
-      raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
-    end
-
-    def self.default
-      if rack_handler = ENV[RACKUP_HANDLER]
-        self.get(rack_handler)
-      elsif rack_handler = ENV[RACK_HANDLER]
-        warn "RACK_HANDLER is deprecated, use RACKUP_HANDLER."
-        self.get(rack_handler)
-      else
-        pick SERVER_NAMES
-      end
-    end
-
-    # Transforms server-name constants to their canonical form as filenames,
-    # then tries to require them but silences the LoadError if not found
-    #
-    # Naming convention:
-    #
-    #   Foo # => 'foo'
-    #   FooBar # => 'foo_bar.rb'
-    #   FooBAR # => 'foobar.rb'
-    #   FOObar # => 'foobar.rb'
-    #   FOOBAR # => 'foobar.rb'
-    #   FooBarBaz # => 'foo_bar_baz.rb'
-    def self.require_handler(prefix, const_name)
-      file = const_name.to_s.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
-        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
-
-      require(::File.join(prefix, file))
-    end
-  end
-end

data/lib/rackup/lobster.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require 'zlib'
-
-require 'rack/constants'
-require 'rack/request'
-require 'rack/response'
-
-module Rackup
-  # Paste has a Pony, Rack has a Lobster!
-  class Lobster
-    include Rack
-
-    LobsterString = Zlib::Inflate.inflate("eJx9kEEOwyAMBO99xd7MAcytUhPlJyj2
-    P6jy9i4k9EQyGAnBarEXeCBqSkntNXsi/ZCvC48zGQoZKikGrFMZvgS5ZHd+aGWVuWwhVF0
-    t1drVmiR42HcWNz5w3QanT+2gIvTVCiE1lm1Y0eU4JGmIIbaKwextKn8rvW+p5PIwFl8ZWJ
-    I8jyiTlhTcYXkekJAzTyYN6E08A+dk8voBkAVTJQ==".delete("\n ").unpack("m*")[0])
-
-    LambdaLobster = lambda { |env|
-      if env[QUERY_STRING].include?("flip")
-        lobster = LobsterString.split("\n").
-          map { |line| line.ljust(42).reverse }.
-          join("\n")
-        href = "?"
-      else
-        lobster = LobsterString
-        href = "?flip"
-      end
-
-      content = ["<title>Lobstericious!</title>",
-                 "<pre>", lobster, "</pre>",
-                 "<a href='#{href}'>flip!</a>"]
-      length = content.inject(0) { |a, e| a + e.size }.to_s
-      [200, { CONTENT_TYPE => "text/html", CONTENT_LENGTH => length }, content]
-    }
-
-    def call(env)
-      req = Request.new(env)
-      if req.GET["flip"] == "left"
-        lobster = LobsterString.split("\n").map do |line|
-          line.ljust(42).reverse.
-            gsub('\\', 'TEMP').
-            gsub('/', '\\').
-            gsub('TEMP', '/').
-            gsub('{', '}').
-            gsub('(', ')')
-        end.join("\n")
-        href = "?flip=right"
-      elsif req.GET["flip"] == "crash"
-        raise "Lobster crashed"
-      else
-        lobster = LobsterString
-        href = "?flip=left"
-      end
-
-      res = Response.new
-      res.write "<title>Lobstericious!</title>"
-      res.write "<pre>"
-      res.write lobster
-      res.write "</pre>"
-      res.write "<p><a href='#{href}'>flip!</a></p>"
-      res.write "<p><a href='?flip=crash'>crash!</a></p>"
-      res.finish
-    end
-
-  end
-end
-
-if $0 == __FILE__
-  # :nocov:
-  require_relative 'server'
-  require_relative 'show_exceptions'
-  require_relative 'lint'
-  Rackup::Server.start(
-    app: Rack::ShowExceptions.new(Rack::Lint.new(Rackup::Lobster.new)), Port: 9292
-  )
-  # :nocov:
-end

data/lib/rackup/server.rb

@@ -1,459 +0,0 @@
-# frozen_string_literal: true
-
-require 'optparse'
-require 'fileutils'
-
-require 'rack/builder'
-require 'rack/common_logger'
-require 'rack/content_length'
-require 'rack/show_exceptions'
-require 'rack/lint'
-require 'rack/tempfile_reaper'
-
-require 'rack/version'
-
-require_relative 'version'
-require_relative 'handler'
-
-module Rackup
-  class Server
-    class Options
-      def parse!(args)
-        options = {}
-        opt_parser = OptionParser.new("", 24, '  ') do |opts|
-          opts.banner = "Usage: rackup [ruby options] [rack options] [rackup config]"
-
-          opts.separator ""
-          opts.separator "Ruby options:"
-
-          lineno = 1
-          opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
-            eval line, TOPLEVEL_BINDING, "-e", lineno
-            lineno += 1
-          }
-
-          opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
-            options[:debug] = true
-          }
-          opts.on("-w", "--warn", "turn warnings on for your script") {
-            options[:warn] = true
-          }
-          opts.on("-q", "--quiet", "turn off logging") {
-            options[:quiet] = true
-          }
-
-          opts.on("-I", "--include PATH",
-                  "specify $LOAD_PATH (may be used more than once)") { |path|
-            (options[:include] ||= []).concat(path.split(":"))
-          }
-
-          opts.on("-r", "--require LIBRARY",
-                  "require the library, before executing your script") { |library|
-            (options[:require] ||= []) << library
-          }
-
-          opts.separator ""
-          opts.separator "Rack options:"
-          opts.on("-b", "--builder BUILDER_LINE", "evaluate a BUILDER_LINE of code as a builder script") { |line|
-            options[:builder] = line
-          }
-
-          opts.on("-s", "--server SERVER", "serve using SERVER (thin/puma/webrick)") { |s|
-            options[:server] = s
-          }
-
-          opts.on("-o", "--host HOST", "listen on HOST (default: localhost)") { |host|
-            options[:Host] = host
-          }
-
-          opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
-            options[:Port] = port
-          }
-
-          opts.on("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
-            name, value = name.split('=', 2)
-            value = true if value.nil?
-            options[name.to_sym] = value
-          }
-
-          opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
-            options[:environment] = e
-          }
-
-          opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
-            options[:daemonize] ||= true
-          }
-
-          opts.on("--daemonize-noclose", "run daemonized in the background without closing stdout/stderr") {
-            options[:daemonize] = :noclose
-          }
-
-          opts.on("-P", "--pid FILE", "file to store PID") { |f|
-            options[:pid] = ::File.expand_path(f)
-          }
-
-          opts.separator ""
-          opts.separator "Profiling options:"
-
-          opts.on("--heap HEAPFILE", "Build the application, then dump the heap to HEAPFILE") do |e|
-            options[:heapfile] = e
-          end
-
-          opts.on("--profile PROFILE", "Dump CPU or Memory profile to PROFILE (defaults to a tempfile)") do |e|
-            options[:profile_file] = e
-          end
-
-          opts.on("--profile-mode MODE", "Profile mode (cpu|wall|object)") do |e|
-            unless %w[cpu wall object].include?(e)
-              raise OptionParser::InvalidOption, "unknown profile mode: #{e}"
-            end
-            options[:profile_mode] = e.to_sym
-          end
-
-          opts.separator ""
-          opts.separator "Common options:"
-
-          opts.on_tail("-h", "-?", "--help", "Show this message") do
-            puts opts
-            puts handler_opts(options)
-
-            exit
-          end
-
-          opts.on_tail("--version", "Show version") do
-            puts "Rack #{Rack::RELEASE}"
-            exit
-          end
-        end
-
-        begin
-          opt_parser.parse! args
-        rescue OptionParser::InvalidOption => e
-          warn e.message
-          abort opt_parser.to_s
-        end
-
-        options[:config] = args.last if args.last && !args.last.empty?
-        options
-      end
-
-      def handler_opts(options)
-        info = []
-        server = Rackup::Handler.get(options[:server]) || Rackup::Handler.default
-        if server && server.respond_to?(:valid_options)
-          info << ""
-          info << "Server-specific options for #{server.name}:"
-
-          has_options = false
-          server.valid_options.each do |name, description|
-            next if /^(Host|Port)[^a-zA-Z]/.match?(name.to_s) # ignore handler's host and port options, we do our own.
-            info << sprintf("  -O %-21s %s", name, description)
-            has_options = true
-          end
-          return "" if !has_options
-        end
-        info.join("\n")
-      rescue NameError, LoadError
-        return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
-      end
-    end
-
-    # Start a new rack server (like running rackup). This will parse ARGV and
-    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
-    #
-    # Providing an options hash will prevent ARGV parsing and will not include
-    # any default options.
-    #
-    # This method can be used to very easily launch a CGI application, for
-    # example:
-    #
-    #  Rack::Server.start(
-    #    :app => lambda do |e|
-    #      [200, {'content-type' => 'text/html'}, ['hello world']]
-    #    end,
-    #    :server => 'cgi'
-    #  )
-    #
-    # Further options available here are documented on Rack::Server#initialize
-    def self.start(options = nil)
-      new(options).start
-    end
-
-    attr_writer :options
-
-    # Options may include:
-    # * :app
-    #     a rack application to run (overrides :config and :builder)
-    # * :builder
-    #     a string to evaluate a Rack::Builder from
-    # * :config
-    #     a rackup configuration file path to load (.ru)
-    # * :environment
-    #     this selects the middleware that will be wrapped around
-    #     your application. Default options available are:
-    #       - development: CommonLogger, ShowExceptions, and Lint
-    #       - deployment: CommonLogger
-    #       - none: no extra middleware
-    #     note: when the server is a cgi server, CommonLogger is not included.
-    # * :server
-    #     choose a specific Rackup::Handler, e.g. cgi, fcgi, webrick
-    # * :daemonize
-    #     if truthy, the server will daemonize itself (fork, detach, etc)
-    #     if :noclose, the server will not close STDOUT/STDERR
-    # * :pid
-    #     path to write a pid file after daemonize
-    # * :Host
-    #     the host address to bind to (used by supporting Rackup::Handler)
-    # * :Port
-    #     the port to bind to (used by supporting Rackup::Handler)
-    # * :AccessLog
-    #     webrick access log options (or supporting Rackup::Handler)
-    # * :debug
-    #     turn on debug output ($DEBUG = true)
-    # * :warn
-    #     turn on warnings ($-w = true)
-    # * :include
-    #     add given paths to $LOAD_PATH
-    # * :require
-    #     require the given libraries
-    #
-    # Additional options for profiling app initialization include:
-    # * :heapfile
-    #     location for ObjectSpace.dump_all to write the output to
-    # * :profile_file
-    #     location for CPU/Memory (StackProf) profile output (defaults to a tempfile)
-    # * :profile_mode
-    #     StackProf profile mode (cpu|wall|object)
-    def initialize(options = nil)
-      @ignore_options = []
-
-      if options
-        @use_default_options = false
-        @options = options
-        @app = options[:app] if options[:app]
-      else
-        @use_default_options = true
-        @options = parse_options(ARGV)
-      end
-    end
-
-    def options
-      merged_options = @use_default_options ? default_options.merge(@options) : @options
-      merged_options.reject { |k, v| @ignore_options.include?(k) }
-    end
-
-    def default_options
-      environment  = ENV['RACK_ENV'] || 'development'
-      default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-      {
-        environment: environment,
-        pid: nil,
-        Port: 9292,
-        Host: default_host,
-        AccessLog: [],
-        config: "config.ru"
-      }
-    end
-
-    def app
-      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
-    end
-
-    class << self
-      def logging_middleware
-        lambda { |server|
-          /CGI/.match?(server.server.name) || server.options[:quiet] ? nil : [Rack::CommonLogger, $stderr]
-        }
-      end
-
-      def default_middleware_by_environment
-        m = Hash.new {|h, k| h[k] = []}
-        m["deployment"] = [
-          [Rack::ContentLength],
-          logging_middleware,
-          [Rack::TempfileReaper]
-        ]
-        m["development"] = [
-          [Rack::ContentLength],
-          logging_middleware,
-          [Rack::ShowExceptions],
-          [Rack::Lint],
-          [Rack::TempfileReaper]
-        ]
-
-        m
-      end
-
-      def middleware
-        default_middleware_by_environment
-      end
-    end
-
-    def middleware
-      self.class.middleware
-    end
-
-    def start(&block)
-      if options[:warn]
-        $-w = true
-      end
-
-      if includes = options[:include]
-        $LOAD_PATH.unshift(*includes)
-      end
-
-      Array(options[:require]).each do |library|
-        require library
-      end
-
-      if options[:debug]
-        $DEBUG = true
-        require 'pp'
-        p options[:server]
-        pp wrapped_app
-        pp app
-      end
-
-      check_pid! if options[:pid]
-
-      # Touch the wrapped app, so that the config.ru is loaded before
-      # daemonization (i.e. before chdir, etc).
-      handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
-        wrapped_app
-      end
-
-      daemonize_app if options[:daemonize]
-
-      write_pid if options[:pid]
-
-      trap(:INT) do
-        if server.respond_to?(:shutdown)
-          server.shutdown
-        else
-          exit
-        end
-      end
-
-      server.run(wrapped_app, **options, &block)
-    end
-
-    def server
-      @_server ||= Handler.get(options[:server]) || Handler.default
-    end
-
-    private
-      def build_app_and_options_from_config
-        if !::File.exist? options[:config]
-          abort "configuration #{options[:config]} not found"
-        end
-
-        return Rack::Builder.parse_file(self.options[:config])
-      end
-
-      def handle_profiling(heapfile, profile_mode, filename)
-        if heapfile
-          require "objspace"
-          ObjectSpace.trace_object_allocations_start
-          yield
-          GC.start
-          ::File.open(heapfile, "w") { |f| ObjectSpace.dump_all(output: f) }
-          exit
-        end
-
-        if profile_mode
-          require "stackprof"
-          require "tempfile"
-
-          make_profile_name(filename) do |filename|
-            ::File.open(filename, "w") do |f|
-              StackProf.run(mode: profile_mode, out: f) do
-                yield
-              end
-              puts "Profile written to: #{filename}"
-            end
-          end
-          exit
-        end
-
-        yield
-      end
-
-      def make_profile_name(filename)
-        if filename
-          yield filename
-        else
-          ::Dir::Tmpname.create("profile.dump") do |tmpname, _, _|
-            yield tmpname
-          end
-        end
-      end
-
-      def build_app_from_string
-        Rack::Builder.new_from_string(self.options[:builder])
-      end
-
-      def parse_options(args)
-        # Don't evaluate CGI ISINDEX parameters.
-        args.clear if ENV.include?(Rack::REQUEST_METHOD)
-
-        @options = opt_parser.parse!(args)
-        @options[:config] = ::File.expand_path(options[:config])
-        ENV["RACK_ENV"] = options[:environment]
-        @options
-      end
-
-      def opt_parser
-        Options.new
-      end
-
-      def build_app(app)
-        middleware[options[:environment]].reverse_each do |middleware|
-          middleware = middleware.call(self) if middleware.respond_to?(:call)
-          next unless middleware
-          klass, *args = middleware
-          app = klass.new(app, *args)
-        end
-        app
-      end
-
-      def wrapped_app
-        @wrapped_app ||= build_app app
-      end
-
-      def daemonize_app
-        # Cannot be covered as it forks
-        # :nocov:
-        Process.daemon(true, options[:daemonize] == :noclose)
-        # :nocov:
-      end
-
-      def write_pid
-        ::File.open(options[:pid], ::File::CREAT | ::File::EXCL | ::File::WRONLY ){ |f| f.write("#{Process.pid}") }
-        at_exit { ::FileUtils.rm_f(options[:pid]) }
-      rescue Errno::EEXIST
-        check_pid!
-        retry
-      end
-
-      def check_pid!
-        return unless ::File.exist?(options[:pid])
-
-        pid = ::File.read(options[:pid]).to_i
-        raise Errno::ESRCH if pid == 0
-
-        Process.kill(0, pid)
-        exit_with_pid(pid)
-      rescue Errno::ESRCH
-        ::File.delete(options[:pid])
-      rescue Errno::EPERM
-        exit_with_pid(pid)
-      end
-
-      def exit_with_pid(pid)
-        $stderr.puts "A server is already running (pid: #{pid}, file: #{options[:pid]})."
-        exit(1)
-      end
-  end
-
-end