http 6.0.0-java

data/lib/http/response/parser.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "llhttp"
+
+module HTTP
+  class Response
+    # HTTP response parser backed by LLHttp
+    # @api private
+    class Parser
+      # The underlying LLHttp parser
+      # @return [LLHttp::Parser] the underlying parser
+      # @api private
+      attr_reader :parser
+
+      # The parsed response headers
+      # @return [HTTP::Headers] the parsed headers
+      # @api private
+      attr_reader :headers
+
+      # The parsed HTTP status code
+      # @return [Integer, nil] the parsed status code
+      # @api private
+      attr_reader :status_code
+
+      # The parsed HTTP version string
+      # @return [String, nil] the parsed HTTP version
+      # @api private
+      attr_reader :http_version
+
+      # Create a new response parser
+      # @return [Parser]
+      # @api private
+      def initialize
+        @handler = Handler.new(self)
+        @parser = LLHttp::Parser.new(@handler, type: :response)
+        reset
+      end
+
+      # Reset parser to initial state
+      # @return [void]
+      # @api private
+      def reset
+        @parser.reset
+        @handler.reset
+        @header_finished = false
+        @message_finished = false
+        @headers = Headers.new
+        @chunk = nil
+        @status_code = nil
+        @http_version = nil
+      end
+
+      # Feed data into the parser
+      # @return [Parser]
+      # @api private
+      def add(data)
+        parser << data
+
+        self
+      rescue LLHttp::Error => e
+        raise IOError, e.message
+      end
+
+      # @see #add
+      # @api private
+      alias << add
+
+      # Reset parser state for informational (1xx) responses
+      # @return [void]
+      # @api private
+      def reset_for_informational
+        @handler.reset
+        @header_finished = false
+        @message_finished = false
+        @headers = Headers.new
+        @chunk = nil
+        @status_code = nil
+        @http_version = nil
+      end
+
+      # Mark headers as finished
+      # @return [void]
+      # @api private
+      def mark_header_finished
+        @header_finished = true
+        @status_code = @parser.status_code
+        @http_version = "#{@parser.http_major}.#{@parser.http_minor}"
+      end
+
+      # Check if headers have been parsed
+      # @return [Boolean]
+      # @api private
+      def headers?
+        @header_finished
+      end
+
+      # Add a parsed header field and value
+      # @return [void]
+      # @api private
+      def add_header(name, value)
+        @headers.add(name, value)
+      end
+
+      # Mark the message as fully parsed
+      # @return [void]
+      # @api private
+      def mark_message_finished
+        @message_finished = true
+      end
+
+      # Check if the full message has been parsed
+      # @return [Boolean]
+      # @api private
+      def finished?
+        @message_finished
+      end
+
+      # Append a body chunk to the buffer
+      # @return [void]
+      # @api private
+      def add_body(chunk)
+        if @chunk
+          @chunk << chunk
+        else
+          @chunk = chunk
+        end
+      end
+
+      # Read up to size bytes from the body buffer
+      # @return [String, nil]
+      # @api private
+      def read(size)
+        return if @chunk.nil?
+
+        if @chunk.bytesize <= size
+          chunk  = @chunk
+          @chunk = nil
+        else
+          chunk = @chunk.byteslice(0, size)
+          @chunk[0, size] = ""
+        end
+
+        chunk
+      end
+
+      # Delegate handler for LLHttp parser callbacks
+      # @api private
+      class Handler < LLHttp::Delegate
+        # Create a new parser handler
+        # @return [Handler]
+        # @api private
+        def initialize(target)
+          @target = target
+          super()
+          reset
+        end
+
+        # Reset handler state
+        # @return [void]
+        # @api private
+        def reset
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
+
+        # Handle a header field token
+        # @return [void]
+        # @api private
+        def on_header_field(field)
+          append_header if @reading_header_value
+          @field << field
+        end
+
+        # Handle a header value token
+        # @return [void]
+        # @api private
+        def on_header_value(value)
+          @reading_header_value = true
+          @field_value << value
+        end
+
+        # Handle headers complete callback
+        # @return [void]
+        # @api private
+        def on_headers_complete
+          append_header if @reading_header_value
+          @target.mark_header_finished
+        end
+
+        # Handle body data callback
+        # @return [void]
+        # @api private
+        def on_body(body)
+          @target.add_body(body)
+        end
+
+        # Handle message complete callback
+        # @return [void]
+        # @api private
+        def on_message_complete
+          if Integer(@target.status_code) < 200
+            @target.reset_for_informational
+          else
+            @target.mark_message_finished
+          end
+        end
+
+        private
+
+        # Flush the current header to the parser
+        # @return [void]
+        # @api private
+        def append_header
+          @target.add_header(@field, @field_value)
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
+      end
+    end
+  end
+end

data/lib/http/response/status/reasons.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# AUTO-GENERATED FILE, DO NOT CHANGE IT MANUALLY
+
+module HTTP
+  class Response
+    class Status
+      # Code to Reason map
+      #
+      # @example Usage
+      #
+      #   REASONS[400] # => "Bad Request"
+      #   REASONS[414] # => "Request-URI Too Long"
+      #
+      # @return [Hash<Fixnum => String>]
+      REASONS = {
+        100 => "Continue",
+        101 => "Switching Protocols",
+        102 => "Processing",
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        203 => "Non-Authoritative Information",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        207 => "Multi-Status",
+        208 => "Already Reported",
+        226 => "IM Used",
+        300 => "Multiple Choices",
+        301 => "Moved Permanently",
+        302 => "Found",
+        303 => "See Other",
+        304 => "Not Modified",
+        305 => "Use Proxy",
+        307 => "Temporary Redirect",
+        308 => "Permanent Redirect",
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        406 => "Not Acceptable",
+        407 => "Proxy Authentication Required",
+        408 => "Request Timeout",
+        409 => "Conflict",
+        410 => "Gone",
+        411 => "Length Required",
+        412 => "Precondition Failed",
+        413 => "Payload Too Large",
+        414 => "URI Too Long",
+        415 => "Unsupported Media Type",
+        416 => "Range Not Satisfiable",
+        417 => "Expectation Failed",
+        421 => "Misdirected Request",
+        422 => "Unprocessable Entity",
+        423 => "Locked",
+        424 => "Failed Dependency",
+        426 => "Upgrade Required",
+        428 => "Precondition Required",
+        429 => "Too Many Requests",
+        431 => "Request Header Fields Too Large",
+        451 => "Unavailable For Legal Reasons",
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout",
+        505 => "HTTP Version Not Supported",
+        506 => "Variant Also Negotiates",
+        507 => "Insufficient Storage",
+        508 => "Loop Detected",
+        510 => "Not Extended",
+        511 => "Network Authentication Required"
+      }.each_value(&:freeze).freeze
+    end
+  end
+end

data/lib/http/response/status.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "http/response/status/reasons"
+
+module HTTP
+  class Response
+    # Represents an HTTP response status code with reason phrase
+    class Status
+      include Comparable
+      extend Forwardable
+
+      class << self
+        # Coerces given value to Status
+        #
+        # @example
+        #   Status.coerce(:bad_request) # => Status.new(400)
+        #
+        # @raise [Error] if coercion is impossible
+        # @param [Symbol, #to_i] object
+        # @return [Status]
+        # @api public
+        def coerce(object)
+          code = case object
+                 when String  then SYMBOL_CODES.fetch(symbolize(object), nil)
+                 when Symbol  then SYMBOL_CODES.fetch(object, nil)
+                 when Numeric then object
+                 end
+
+          return new code if code
+
+          raise Error, "Can't coerce #{object.class}(#{object}) to #{self}"
+        end
+        alias [] coerce
+
+        private
+
+        # Symbolizes given string
+        #
+        # @param [#to_s] str
+        # @return [Symbol]
+        # @api private
+        def symbolize(str)
+          str.downcase.tr("- ", "_").to_sym
+        end
+      end
+
+      # Code to Symbol map
+      #
+      # @example Usage
+      #
+      #   SYMBOLS[400] # => :bad_request
+      #   SYMBOLS[414] # => :request_uri_too_long
+      #   SYMBOLS[418] # => :im_a_teapot
+      #
+      # @return [Hash<Fixnum => Symbol>]
+      SYMBOLS = REASONS.transform_values { |v| symbolize(v) }.freeze
+
+      # Reversed {SYMBOLS} map.
+      #
+      # @example Usage
+      #
+      #   SYMBOL_CODES[:bad_request]           # => 400
+      #   SYMBOL_CODES[:request_uri_too_long]  # => 414
+      #   SYMBOL_CODES[:im_a_teapot]           # => 418
+      #
+      # @return [Hash<Symbol => Fixnum>]
+      SYMBOL_CODES = SYMBOLS.to_h { |k, v| [v, k] }.freeze
+
+      # The numeric status code
+      #
+      # @example
+      #   status.code # => 200
+      #
+      # @return [Fixnum] status code
+      # @api public
+      attr_reader :code
+
+      # @!method to_i
+      #   Convert status to Integer
+      #   @example
+      #     status.to_i # => 200
+      #   @return [Integer]
+      #   @api public
+
+      # @!method to_int
+      #   Implicit conversion to Integer
+      #   @example
+      #     status.to_int # => 200
+      #   @return [Integer]
+      #   @api public
+      def_delegators :@code, :to_i, :to_int
+
+      # Create a new Status from a value that responds to #to_i
+      #
+      # @example
+      #   Status.new(200)
+      #
+      # @param [#to_i] obj
+      # @return [Status]
+      # @api public
+      def initialize(obj)
+        raise TypeError, "Expected #{obj.inspect} to respond to #to_i" unless obj.respond_to?(:to_i)
+
+        @code = obj.to_i
+      end
+
+      # Compare status codes for ordering
+      #
+      # @example
+      #   Status.new(200) <=> Status.new(404) # => -1
+      #
+      # @param [#to_i] other
+      # @return [Integer, nil]
+      # @api public
+      def <=>(other)
+        return nil unless other.respond_to?(:to_i)
+
+        code <=> other.to_i
+      end
+
+      # Hash value based on status code
+      #
+      # @example
+      #   Status.new(200).hash
+      #
+      # @return [Integer]
+      # @api public
+      def hash
+        code.hash
+      end
+
+      # Return the reason phrase for the status code
+      #
+      # @example
+      #   status.reason # => "OK"
+      #
+      # @see REASONS
+      # @return [String, nil] status message
+      # @api public
+      def reason
+        REASONS[code]
+      end
+
+      # Return string representation of HTTP status
+      #
+      # @example
+      #   status.to_s # => "200 OK"
+      #
+      # @return [String]
+      # @api public
+      def to_s
+        reason ? "#{code} #{reason}" : code.to_s
+      end
+
+      # Check if status code is informational (1XX)
+      #
+      # @example
+      #   status.informational? # => false
+      #
+      # @return [Boolean]
+      # @api public
+      def informational?
+        100 <= code && code < 200
+      end
+
+      # Check if status code is successful (2XX)
+      #
+      # @example
+      #   status.success? # => true
+      #
+      # @return [Boolean]
+      # @api public
+      def success?
+        200 <= code && code < 300
+      end
+
+      # Check if status code is redirection (3XX)
+      #
+      # @example
+      #   status.redirect? # => false
+      #
+      # @return [Boolean]
+      # @api public
+      def redirect?
+        300 <= code && code < 400
+      end
+
+      # Check if status code is client error (4XX)
+      #
+      # @example
+      #   status.client_error? # => false
+      #
+      # @return [Boolean]
+      # @api public
+      def client_error?
+        400 <= code && code < 500
+      end
+
+      # Check if status code is server error (5XX)
+      #
+      # @example
+      #   status.server_error? # => false
+      #
+      # @return [Boolean]
+      # @api public
+      def server_error?
+        500 <= code && code < 600
+      end
+
+      # Symbolized {#reason}
+      #
+      # @example
+      #   status.to_sym # => :ok
+      #
+      # @return [nil] unless code is well-known (see REASONS)
+      # @return [Symbol]
+      # @api public
+      def to_sym
+        SYMBOLS[code]
+      end
+
+      # Printable version of HTTP Status
+      #
+      # @example
+      #   status.inspect # => "#<HTTP::Response::Status 200 OK>"
+      #
+      # (see String#inspect)
+      # @return [String]
+      # @api public
+      def inspect
+        "#<#{self.class} #{self}>"
+      end
+
+      # Pattern matching interface for matching against status code and reason
+      #
+      # @example
+      #   case response.status
+      #   in { code: 200..299 }
+      #     "success"
+      #   in { code: 400.. }
+      #     "error"
+      #   end
+      #
+      # @param keys [Array<Symbol>, nil] keys to extract, or nil for all
+      # @return [Hash{Symbol => Object}]
+      # @api public
+      def deconstruct_keys(keys)
+        hash = { code: code, reason: reason }
+        keys ? hash.slice(*keys) : hash
+      end
+
+      SYMBOLS.each do |code, symbol|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{symbol}?      # def bad_request?
+            #{code} == code   #   400 == code
+          end                 # end
+        RUBY
+      end
+    end
+  end
+end