rackup 1.0.1 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8cc45621b46eb19ef735b5e68dd3738292345ccf3bb43554c48f2517c323cbd
-  data.tar.gz: 49d22e5f97022cc38312ba0afce490ac81f005a6240ee4f3bab521f23f928e8a
+  metadata.gz: 1e1f9c41ea38c6bde36ea2c4e61d66ffe4a61d2a92fe73bbbe4090d0adc3cad6
+  data.tar.gz: e08ff923a6568b6b30f5810cbfcfc046e536d944086e97960cf3869daaff0ae5
 SHA512:
-  metadata.gz: 84de21b2a8b4bb24a7d4dc58cbe6b74e63bfbf90c7a45ac3dce5cdf900369f7f8664b3e56e4a78cb5d4c68f8228021e09cb2ad9424da208896a7ae5adab0ebe3
-  data.tar.gz: d9c659a4b6aba77ddefa35947bade7c6ee89e7a6ab3502851fce839c35cc75597649b76c7eff089d84f8e304a70758f0f887e9c0f26ac8e2df28d1d1a93478c9
+  metadata.gz: 0fb28d087940a39f79a4bfa6749455c41bae3c48ec652b054c1fc99acf4b6176f892a7b6ffb300304ceb2bd5378f129c3793da08e507628f1acb02c31cf3d10c
+  data.tar.gz: 5ab015f40bd2f87d3ae8ae71afc10a567ce1d6cb4ed7be74b029f4f0e8ccaf7292a96df731e1b5b13f6ab45865b5a2bbe11ad32b47dc65bed7e058567e5a51b0

data/bin/rackup

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

data/lib/rackup/handler/cgi.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2023, by Samuel Williams.
+
+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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2023, by Samuel Williams.
+# Copyright, 2022, by Jeremy Evans.
+
+require 'webrick'
+require 'stringio'
+
+require 'rack/constants'
+require_relative '../handler'
+require_relative '../version'
+
+require_relative '../stream'
+
+module Rackup
+  module Handler
+    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
+      # A WEBrick HTTPServer subclass that invokes the Rack app directly,
+      # bypassing the mount table and default OPTIONS * handling.
+      class Server < ::WEBrick::HTTPServer
+        def initialize(app, config)
+          super(config)
+          @handler = Handler::WEBrick.new(self, app)
+        end
+
+        def service(req, res)
+          @handler.service(req, res)
+        end
+      end
+
+      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 = Server.new(app, options)
+        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
+
+      # This handles mapping the WEBrick request to a Rack input stream.
+      class Input
+        include Stream::Reader
+
+        def initialize(request)
+          @request = request
+
+          @reader = Fiber.new do
+            @request.body do |chunk|
+              Fiber.yield(chunk)
+            end
+
+            Fiber.yield(nil)
+
+            # End of stream:
+            @reader = nil
+          end
+        end
+
+        def close
+          @request = nil
+          @reader = nil
+        end
+
+        private
+
+        # Read one chunk from the request body.
+        def read_next
+          @reader&.resume
+        end
+      end
+
+      def service(req, res)
+        env = req.meta_vars
+        env.delete_if { |k, v| v.nil? }
+
+        input = Input.new(req)
+
+        env.update(
+          ::Rack::RACK_INPUT => input,
+          ::Rack::RACK_ERRORS => $stderr,
+          ::Rack::RACK_URL_SCHEME => ["yes", "on", "1"].include?(env[::Rack::HTTPS]) ? "https" : "http",
+          ::Rack::RACK_IS_HIJACK => true,
+        )
+
+        env[::Rack::QUERY_STRING] ||= ""
+
+        # Handle OPTIONS * requests which have no path
+        if req.unparsed_uri == "*"
+          env[::Rack::PATH_INFO] = "*"
+          env[::Rack::REQUEST_PATH] = "*"
+
+          # Ensure SERVER_NAME and SERVER_PORT are set from server config.
+          # (WEBrick allows these to be nil for OPTIONS * requests)
+          # See https://github.com/ruby/webrick/pull/182 for a proper fix.
+          server_name = env[::Rack::SERVER_NAME]
+          if server_name.nil? || server_name == ""
+            env[::Rack::SERVER_NAME] = @server[:ServerName] || @server[:BindAddress] || "localhost"
+          end
+
+          # Legacy versions of WEBrick can set server_port to "" in some cases:
+          server_port = env[::Rack::SERVER_PORT]
+          if server_port.nil? || server_port == ""
+            env[::Rack::SERVER_PORT] = (@server[:Port] || 80).to_s
+          end
+        else
+          unless env[::Rack::PATH_INFO] == ""
+            # Strip the script name prefix from the path to get path info
+            script_name_length = env[::Rack::SCRIPT_NAME].length
+            env[::Rack::PATH_INFO] = req.request_uri.path[script_name_length..-1] || ""
+          end
+          env[::Rack::REQUEST_PATH] ||= env[::Rack::SCRIPT_NAME] + env[::Rack::PATH_INFO]
+        end
+
+        status, headers, body = @app.call(env)
+        begin
+          res.status = status
+
+          if value = headers[::Rack::RACK_HIJACK]
+            io_lambda = value
+            body = nil
+          elsif !body.respond_to?(:to_path) && !body.respond_to?(:each)
+            io_lambda = body
+            body = nil
+          end
+
+          if value = headers.delete('set-cookie')
+            res.cookies.concat(Array(value))
+          end
+
+          headers.each do |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
+          end
+
+          if io_lambda
+            protocol = headers['rack.protocol'] || headers['upgrade']
+
+            if protocol
+              # Set all the headers correctly for an upgrade response:
+              res.upgrade!(protocol)
+            end
+            res.body = io_lambda
+          elsif body.respond_to?(:to_path)
+            res.body = ::File.open(body.to_path, 'rb')
+          else
+            buffer = String.new
+            body.each do |part|
+              buffer << part
+            end
+            res.body = buffer
+          end
+        ensure
+          body.close if body.respond_to?(:close)
+        end
+      end
+    end
+
+    register :webrick, WEBrick
+  end
+end

data/lib/rackup/handler.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2023, by Samuel Williams.
+
+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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2022-2023, by Samuel Williams.
+
+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