rack 2.2.10 → 3.1.10

data/lib/rack/chunked.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Middleware that applies chunked transfer encoding to response bodies
-  # when the response does not include a Content-Length header.
-  #
-  # This supports the Trailer response header to allow the use of trailing
-  # headers in the chunked encoding.  However, using this requires you manually
-  # specify a response body that supports a +trailers+ method.  Example:
-  #
-  #   [200, { 'Trailer' => 'Expires'}, ["Hello", "World"]]
-  #   # error raised
-  #
-  #   body = ["Hello", "World"]
-  #   def body.trailers
-  #     { 'Expires' => Time.now.to_s }
-  #   end
-  #   [200, { 'Trailer' => 'Expires'}, body]
-  #   # No exception raised
-  class Chunked
-    include Rack::Utils
-
-    # A body wrapper that emits chunked responses.
-    class Body
-      TERM = "\r\n"
-      TAIL = "0#{TERM}"
-
-      # Store the response body to be chunked.
-      def initialize(body)
-        @body = body
-      end
-
-      # For each element yielded by the response body, yield
-      # the element in chunked encoding.
-      def each(&block)
-        term = TERM
-        @body.each do |chunk|
-          size = chunk.bytesize
-          next if size == 0
-
-          yield [size.to_s(16), term, chunk.b, term].join
-        end
-        yield TAIL
-        yield_trailers(&block)
-        yield term
-      end
-
-      # Close the response body if the response body supports it.
-      def close
-        @body.close if @body.respond_to?(:close)
-      end
-
-      private
-
-      # Do nothing as this class does not support trailer headers.
-      def yield_trailers
-      end
-    end
-
-    # A body wrapper that emits chunked responses and also supports
-    # sending Trailer headers.  Note that the response body provided to
-    # initialize must have a +trailers+ method that returns a hash
-    # of trailer headers, and the rack response itself should have a
-    # Trailer header listing the headers that the +trailers+ method
-    # will return.
-    class TrailerBody < Body
-      private
-
-      # Yield strings for each trailer header.
-      def yield_trailers
-        @body.trailers.each_pair do |k, v|
-          yield "#{k}: #{v}\r\n"
-        end
-      end
-    end
-
-    def initialize(app)
-      @app = app
-    end
-
-    # Whether the HTTP version supports chunked encoding (HTTP 1.1 does).
-    def chunkable_version?(ver)
-      case ver
-      # pre-HTTP/1.0 (informally "HTTP/0.9") HTTP requests did not have
-      # a version (nor response headers)
-      when 'HTTP/1.0', nil, 'HTTP/0.9'
-        false
-      else
-        true
-      end
-    end
-
-    # If the rack app returns a response that should have a body,
-    # but does not have Content-Length or Transfer-Encoding headers,
-    # modify the response to use chunked Transfer-Encoding.
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = HeaderHash[headers]
-
-      if chunkable_version?(env[SERVER_PROTOCOL]) &&
-         !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
-         !headers[CONTENT_LENGTH] &&
-         !headers[TRANSFER_ENCODING]
-
-        headers[TRANSFER_ENCODING] = 'chunked'
-        if headers['Trailer']
-          body = TrailerBody.new(body)
-        else
-          body = Body.new(body)
-        end
-      end
-
-      [status, headers, body]
-    end
-  end
-end

data/lib/rack/core_ext/regexp.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-# Regexp has `match?` since Ruby 2.4
-# so to support Ruby < 2.4 we need to define this method
-
-module Rack
-  module RegexpExtensions
-    refine Regexp do
-      def match?(string, pos = 0)
-        !!match(string, pos)
-      end
-    end unless //.respond_to?(:match?)
-  end
-end

data/lib/rack/file.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'files'
-
-module Rack
-  File = Files
-end

data/lib/rack/handler/cgi.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Handler
-    class CGI
-      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_VERSION      => Rack::VERSION,
-          RACK_INPUT        => Rack::RewindableInput.new($stdin),
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => true,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        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
-  end
-end

data/lib/rack/handler/fastcgi.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'fcgi'
-require 'socket'
-
-if defined? FCGI::Stream
-  class FCGI::Stream
-    alias _rack_read_without_buffer read
-
-    def read(n, buffer = nil)
-      buf = _rack_read_without_buffer n
-      buffer.replace(buf.to_s)  if buffer
-      buf
-    end
-  end
-end
-
-module Rack
-  module Handler
-    class FastCGI
-      def self.run(app, **options)
-        if options[:File]
-          STDIN.reopen(UNIXServer.new(options[:File]))
-        elsif options[:Port]
-          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
-        end
-        FCGI.each { |request|
-          serve request, app
-        }
-      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)",
-          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
-        }
-      end
-
-      def self.serve(request, app)
-        env = request.env
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
-
-        rack_input = RewindableInput.new(request.in)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => request.err,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
-        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
-
-        begin
-          status, headers, body = app.call(env)
-          begin
-            send_headers request.out, status, headers
-            send_body request.out, body
-          ensure
-            body.close  if body.respond_to? :close
-          end
-        ensure
-          rack_input.close
-          request.finish
-        end
-      end
-
-      def self.send_headers(out, status, headers)
-        out.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            out.print "#{k}: #{v}\r\n"
-          }
-        }
-        out.print "\r\n"
-        out.flush
-      end
-
-      def self.send_body(out, body)
-        body.each { |part|
-          out.print part
-          out.flush
-        }
-      end
-    end
-  end
-end

data/lib/rack/handler/lsws.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'lsapi'
-
-module Rack
-  module Handler
-    class LSWS
-      def self.run(app, **options)
-        while LSAPI.accept != nil
-          serve app
-        end
-      end
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-        env[SCRIPT_NAME] = "" if env[SCRIPT_NAME] == "/"
-
-        rack_input = RewindableInput.new($stdin.read.to_s)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        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
-      ensure
-        rack_input.close
-      end
-      def self.send_headers(status, headers)
-        print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            print "#{k}: #{v}\r\n"
-          }
-        }
-        print "\r\n"
-        STDOUT.flush
-      end
-      def self.send_body(body)
-        body.each { |part|
-          print part
-          STDOUT.flush
-        }
-      end
-    end
-  end
-end

data/lib/rack/handler/scgi.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'scgi'
-require 'stringio'
-
-module Rack
-  module Handler
-    class SCGI < ::SCGI::Processor
-      attr_accessor :app
-
-      def self.run(app, **options)
-        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
-        new(options.merge(app: app,
-                          host: options[:Host],
-                          port: options[:Port],
-                          socket: options[:Socket])).listen
-      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 initialize(settings = {})
-        @app = settings[:app]
-        super(settings)
-      end
-
-      def process_request(request, input_body, socket)
-        env = Hash[request]
-        env.delete "HTTP_CONTENT_TYPE"
-        env.delete "HTTP_CONTENT_LENGTH"
-        env[REQUEST_PATH], env[QUERY_STRING] = env["REQUEST_URI"].split('?', 2)
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[PATH_INFO] = env[REQUEST_PATH]
-        env[QUERY_STRING] ||= ""
-        env[SCRIPT_NAME] = ""
-
-        rack_input = StringIO.new(input_body)
-        rack_input.set_encoding(Encoding::BINARY)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => true,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
-        )
-
-        status, headers, body = app.call(env)
-        begin
-          socket.write("Status: #{status}\r\n")
-          headers.each do |k, vs|
-            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
-          end
-          socket.write("\r\n")
-          body.each {|s| socket.write(s)}
-        ensure
-          body.close if body.respond_to? :close
-        end
-      end
-    end
-  end
-end

data/lib/rack/handler/thin.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "thin"
-require "thin/server"
-require "thin/logging"
-require "thin/backends/tcp_server"
-
-module Rack
-  module Handler
-    class Thin
-      def self.run(app, **options)
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        host = options.delete(:Host) || default_host
-        port = options.delete(:Port) || 8080
-        args = [host, port, app, options]
-        # Thin versions below 0.8.0 do not support additional options
-        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
-        server = ::Thin::Server.new(*args)
-        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
-    end
-  end
-end

data/lib/rack/handler/webrick.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'webrick'
-require 'stringio'
-
-# 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 Rack
-  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 "/", Rack::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_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => true,
-          RACK_MULTIPROCESS => false,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http",
-          RACK_IS_HIJACK    => true,
-          RACK_HIJACK       => lambda { raise NotImplementedError, "only partial hijack is supported."},
-          RACK_HIJACK_IO    => nil
-        )
-
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        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.to_i
-          io_lambda = nil
-          headers.each { |k, vs|
-            if k == RACK_HIJACK
-              io_lambda = vs
-            elsif k.downcase == "set-cookie"
-              res.cookies.concat vs.split("\n")
-            else
-              # Since WEBrick won't accept repeated headers,
-              # merge the values per RFC 1945 section 4.2.
-              res[k] = vs.split("\n").join(", ")
-            end
-          }
-
-          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
-  end
-end

data/lib/rack/handler.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # *Handlers* connect web servers with Rack.
-  #
-  # Rack includes Handlers for Thin, WEBrick, FastCGI, CGI, SCGI
-  # and LiteSpeed.
-  #
-  # 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
-    def self.get(server)
-      return unless server
-      server = server.to_s
-
-      unless @handlers.include? server
-        load_error = try_require('rack/handler', server)
-      end
-
-      if klass = @handlers[server]
-        const_get(klass)
-      else
-        const_get(server, false)
-      end
-
-    rescue NameError => name_error
-      raise load_error || name_error
-    end
-
-    # Select first available Rack handler given an `Array` of server names.
-    # Raises `LoadError` if no handler was found.
-    #
-    #   > pick ['thin', 'webrick']
-    #   => Rack::Handler::WEBrick
-    def self.pick(server_names)
-      server_names = Array(server_names)
-      server_names.each do |server_name|
-        begin
-          return get(server_name.to_s)
-        rescue LoadError, NameError
-        end
-      end
-
-      raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
-    end
-
-    SERVER_NAMES = %w(puma thin falcon webrick).freeze
-    private_constant :SERVER_NAMES
-
-    def self.default
-      # Guess.
-      if ENV.include?("PHP_FCGI_CHILDREN")
-        Rack::Handler::FastCGI
-      elsif ENV.include?(REQUEST_METHOD)
-        Rack::Handler::CGI
-      elsif ENV.include?("RACK_HANDLER")
-        self.get(ENV["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.try_require(prefix, const_name)
-      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
-        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
-
-      require(::File.join(prefix, file))
-      nil
-    rescue LoadError => error
-      error
-    end
-
-    def self.register(server, klass)
-      @handlers ||= {}
-      @handlers[server.to_s] = klass.to_s
-    end
-
-    autoload :CGI, "rack/handler/cgi"
-    autoload :FastCGI, "rack/handler/fastcgi"
-    autoload :WEBrick, "rack/handler/webrick"
-    autoload :LSWS, "rack/handler/lsws"
-    autoload :SCGI, "rack/handler/scgi"
-    autoload :Thin, "rack/handler/thin"
-
-    register 'cgi', 'Rack::Handler::CGI'
-    register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'webrick', 'Rack::Handler::WEBrick'
-    register 'lsws', 'Rack::Handler::LSWS'
-    register 'scgi', 'Rack::Handler::SCGI'
-    register 'thin', 'Rack::Handler::Thin'
-  end
-end