rackup 1.0.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8cc45621b46eb19ef735b5e68dd3738292345ccf3bb43554c48f2517c323cbd
-  data.tar.gz: 49d22e5f97022cc38312ba0afce490ac81f005a6240ee4f3bab521f23f928e8a
+  metadata.gz: 500a1eebb3f2dc73a7f4e0b50753603f19f4b2c841a55c01c047188ed6d2214f
+  data.tar.gz: 7e51b56d52e396e9c208b06c7a25be3389d0df9c55c3c3333f0379e5aec73719
 SHA512:
-  metadata.gz: 84de21b2a8b4bb24a7d4dc58cbe6b74e63bfbf90c7a45ac3dce5cdf900369f7f8664b3e56e4a78cb5d4c68f8228021e09cb2ad9424da208896a7ae5adab0ebe3
-  data.tar.gz: d9c659a4b6aba77ddefa35947bade7c6ee89e7a6ab3502851fce839c35cc75597649b76c7eff089d84f8e304a70758f0f887e9c0f26ac8e2df28d1d1a93478c9
+  metadata.gz: 9aa96ee4990bf4d93f23c4d3d2b16b28c793e9f4fabc2a24a007f241067262168608bcf0e2091368131563dfe9bb4b7fc2845330a75e96c7886b956a12e5f933
+  data.tar.gz: 62821749a10a8f337c3f0b4dde6f83fab067c68a1d3864f74a8cd1b28fb62d8be8430a571112ea5f5b60b753ad278140d130ec3f73c3a67f739345b288f73a49

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,162 @@
+# 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
+      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
+
+      # 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] ||= ""
+        unless env[::Rack::PATH_INFO] == ""
+          path, n = req.request_uri.path, env[::Rack::SCRIPT_NAME].length
+          env[::Rack::PATH_INFO] = path[n, path.length - n]
+        end
+        env[::Rack::REQUEST_PATH] ||= [env[::Rack::SCRIPT_NAME], env[::Rack::PATH_INFO]].join
+
+        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