http 4.4.1 → 5.0.1

data/lib/http/mime_type/adapter.rb

@@ -14,13 +14,15 @@ module HTTP
         def_delegators :instance, :encode, :decode
       end
 
+      # rubocop:disable Style/DocumentDynamicEvalDefinition
       %w[encode decode].each do |operation|
-        class_eval <<-RUBY, __FILE__, __LINE__
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{operation}(*)
             fail Error, "\#{self.class} does not supports ##{operation}"
           end
         RUBY
       end
+      # rubocop:enable Style/DocumentDynamicEvalDefinition
     end
   end
 end

data/lib/http/mime_type/json.rb

@@ -10,6 +10,7 @@ module HTTP
       # Encodes object to JSON
       def encode(obj)
         return obj.to_json if obj.respond_to?(:to_json)
+
         ::JSON.dump obj
       end
 

data/lib/http/options.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
-
 require "http/headers"
 require "openssl"
 require "socket"
 require "http/uri"
 
 module HTTP
-  class Options
+  class Options # rubocop:disable Metrics/ClassLength
     @default_socket_class     = TCPSocket
     @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
     @default_timeout_class    = HTTP::Timeout::Null
@@ -18,9 +16,8 @@ module HTTP
       attr_accessor :default_socket_class, :default_ssl_socket_class, :default_timeout_class
       attr_reader :available_features
 
-      def new(options = {}) # rubocop:disable Style/OptionHash
-        return options if options.is_a?(self)
-        super
+      def new(options = {})
+        options.is_a?(self) ? options : super
       end
 
       def defined_options
@@ -35,7 +32,7 @@ module HTTP
 
       def def_option(name, reader_only: false, &interpreter)
         defined_options << name.to_sym
-        interpreter ||= lambda { |v| v }
+        interpreter ||= ->(v) { v }
 
         if reader_only
           attr_reader name
@@ -50,7 +47,7 @@ module HTTP
       end
     end
 
-    def initialize(options = {}) # rubocop:disable Style/OptionHash
+    def initialize(options = {})
       defaults = {
         :response           => :auto,
         :proxy              => {},

data/lib/http/redirector.rb

@@ -39,7 +39,7 @@ module HTTP
     # @param [Hash] opts
     # @option opts [Boolean] :strict (true) redirector hops policy
     # @option opts [#to_i] :max_hops (5) maximum allowed amount of hops
-    def initialize(opts = {}) # rubocop:disable Style/OptionHash
+    def initialize(opts = {})
       @strict   = opts.fetch(:strict, true)
       @max_hops = opts.fetch(:max_hops, 5).to_i
     end
@@ -90,6 +90,7 @@ module HTTP
 
       if UNSAFE_VERBS.include?(verb) && STRICT_SENSITIVE_CODES.include?(code)
         raise StateError, "can't follow #{@response.status} redirect" if @strict
+
         verb = :get
       end
 

data/lib/http/request.rb

@@ -46,7 +46,10 @@ module HTTP
       :patch,
 
       # draft-reschke-webdav-search: WebDAV Search
-      :search
+      :search,
+
+      # RFC 4791: Calendaring Extensions to WebDAV -- CalDAV
+      :mkcalendar
     ].freeze
 
     # Allowed schemes
@@ -54,10 +57,10 @@ module HTTP
 
     # Default ports of supported schemes
     PORTS = {
-      :http   => 80,
-      :https  => 443,
-      :ws     => 80,
-      :wss    => 443
+      :http  => 80,
+      :https => 443,
+      :ws    => 80,
+      :wss   => 443
     }.freeze
 
     # Method is given as a lowercase symbol e.g. :get, :post
@@ -101,12 +104,26 @@ module HTTP
       headers = self.headers.dup
       headers.delete(Headers::HOST)
 
+      new_body = body.source
+      if verb == :get
+        # request bodies should not always be resubmitted when following a redirect
+        # some servers will close the connection after receiving the request headers
+        # which may cause Errno::ECONNRESET: Connection reset by peer
+        # see https://github.com/httprb/http/issues/649
+        # new_body = Request::Body.new(nil)
+        new_body = nil
+        # the CONTENT_TYPE header causes problems if set on a get request w/ an empty body
+        # the server might assume that there should be content if it is set to multipart
+        # rack raises EmptyContentError if this happens
+        headers.delete(Headers::CONTENT_TYPE)
+      end
+
       self.class.new(
         :verb           => verb,
         :uri            => @uri.join(uri),
         :headers        => headers,
         :proxy          => proxy,
-        :body           => body.source,
+        :body           => new_body,
         :version        => version,
         :uri_normalizer => uri_normalizer
       )
@@ -168,8 +185,8 @@ module HTTP
     # Headers to send with proxy connect request
     def proxy_connect_headers
       connect_headers = HTTP::Headers.coerce(
-        Headers::HOST        => headers[Headers::HOST],
-        Headers::USER_AGENT  => headers[Headers::USER_AGENT]
+        Headers::HOST       => headers[Headers::HOST],
+        Headers::USER_AGENT => headers[Headers::USER_AGENT]
       )
 
       connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if using_authenticated_proxy?
@@ -213,7 +230,7 @@ module HTTP
 
     # @return [String] Default host (with port if needed) header value.
     def default_host_header_value
-      PORTS[@scheme] != port ? "#{host}:#{port}" : host
+      PORTS[@scheme] == port ? host : "#{host}:#{port}"
     end
 
     def prepare_body(body)
@@ -223,8 +240,8 @@ module HTTP
     def prepare_headers(headers)
       headers = HTTP::Headers.coerce(headers || {})
 
-      headers[Headers::HOST]        ||= default_host_header_value
-      headers[Headers::USER_AGENT]  ||= USER_AGENT
+      headers[Headers::HOST]       ||= default_host_header_value
+      headers[Headers::USER_AGENT] ||= USER_AGENT
 
       headers
     end

data/lib/http/request/body.rb

@@ -19,6 +19,7 @@ module HTTP
           @source.bytesize
         elsif @source.respond_to?(:read)
           raise RequestError, "IO object must respond to #size" unless @source.respond_to?(:size)
+
           @source.size
         elsif @source.nil?
           0

data/lib/http/request/writer.rb

@@ -108,12 +108,13 @@ module HTTP
         until data.empty?
           length = @socket.write(data)
           break unless data.bytesize > length
+
           data = data.byteslice(length..-1)
         end
       rescue Errno::EPIPE
         raise
-      rescue IOError, SocketError, SystemCallError => ex
-        raise ConnectionError, "error writing to socket: #{ex}", ex.backtrace
+      rescue IOError, SocketError, SystemCallError => e
+        raise ConnectionError, "error writing to socket: #{e}", e.backtrace
       end
     end
   end

data/lib/http/response.rb

@@ -7,7 +7,6 @@ require "http/content_type"
 require "http/mime_type"
 require "http/response/status"
 require "http/response/inflater"
-require "http/uri"
 require "http/cookie_jar"
 require "time"
 
@@ -26,8 +25,8 @@ module HTTP
     # @return [Body]
     attr_reader :body
 
-    # @return [URI, nil]
-    attr_reader :uri
+    # @return [Request]
+    attr_reader :request
 
     # @return [Hash]
     attr_reader :proxy_headers
@@ -41,10 +40,10 @@ module HTTP
     # @option opts [HTTP::Connection] :connection
     # @option opts [String] :encoding Encoding to use when reading body
     # @option opts [String] :body
-    # @option opts [String] :uri
+    # @option opts [HTTP::Request] request
     def initialize(opts)
       @version       = opts.fetch(:version)
-      @uri           = HTTP::URI.parse(opts.fetch(:uri)) if opts.include? :uri
+      @request       = opts.fetch(:request)
       @status        = HTTP::Response::Status.new(opts.fetch(:status))
       @headers       = HTTP::Headers.coerce(opts[:headers] || {})
       @proxy_headers = HTTP::Headers.coerce(opts[:proxy_headers] || {})
@@ -61,24 +60,28 @@ module HTTP
 
     # @!method reason
     #   @return (see HTTP::Response::Status#reason)
-    def_delegator :status, :reason
+    def_delegator :@status, :reason
 
     # @!method code
     #   @return (see HTTP::Response::Status#code)
-    def_delegator :status, :code
+    def_delegator :@status, :code
 
     # @!method to_s
     #   (see HTTP::Response::Body#to_s)
-    def_delegator :body, :to_s
+    def_delegator :@body, :to_s
     alias to_str to_s
 
     # @!method readpartial
     #   (see HTTP::Response::Body#readpartial)
-    def_delegator :body, :readpartial
+    def_delegator :@body, :readpartial
 
     # @!method connection
     #   (see HTTP::Response::Body#connection)
-    def_delegator :body, :connection
+    def_delegator :@body, :connection
+
+    # @!method uri
+    #   @return (see HTTP::Request#uri)
+    def_delegator :@request, :uri
 
     # Returns an Array ala Rack: `[status, headers, body]`
     #
@@ -150,12 +153,11 @@ module HTTP
 
     # Parse response body with corresponding MIME type adapter.
     #
-    # @param [#to_s] as Parse as given MIME type
-    #   instead of the one determined from headers
-    # @raise [HTTP::Error] if adapter not found
+    # @param type [#to_s] Parse as given MIME type.
+    # @raise (see MimeType.[])
     # @return [Object]
-    def parse(as = nil)
-      MimeType[as || mime_type].decode to_s
+    def parse(type = nil)
+      MimeType[type || mime_type].decode to_s
     end
 
     # Inspect a response

data/lib/http/response/body.rb

@@ -27,8 +27,7 @@ module HTTP
       # (see HTTP::Client#readpartial)
       def readpartial(*args)
         stream!
-        chunk = @stream.readpartial(*args)
-        chunk.force_encoding(@encoding) if chunk
+        @stream.readpartial(*args)&.force_encoding(@encoding)
       end
 
       # Iterate over the body, allowing it to be enumerable
@@ -64,6 +63,7 @@ module HTTP
       # Assert that the body is actively being streamed
       def stream!
         raise StateError, "body has already been consumed" if @streaming == false
+
         @streaming = true
       end
 

data/lib/http/response/inflater.rb

@@ -16,7 +16,7 @@ module HTTP
         if chunk
           chunk = zstream.inflate(chunk)
         elsif !zstream.closed?
-          zstream.finish
+          zstream.finish if zstream.total_in.positive?
           zstream.close
         end
         chunk

data/lib/http/response/parser.rb

@@ -1,69 +1,63 @@
 # frozen_string_literal: true
 
-require "http-parser"
+require "llhttp"
 
 module HTTP
   class Response
     # @api private
-    #
-    # NOTE(ixti): This class is a subject of future refactoring, thus don't
-    #   expect this class API to be stable until this message disappears and
-    #   class is not marked as private anymore.
     class Parser
-      attr_reader :headers
+      attr_reader :parser, :headers, :status_code, :http_version
 
       def initialize
-        @state  = HttpParser::Parser.new_instance { |i| i.type = :response }
-        @parser = HttpParser::Parser.new(self)
-
+        @handler = Handler.new(self)
+        @parser = LLHttp::Parser.new(@handler, :type => :response)
         reset
       end
 
-      # @return [self]
-      def add(data)
-        # XXX(ixti): API doc of HttpParser::Parser is misleading, it says that
-        #   it returns boolean true if data was parsed successfully, but instead
-        #   it's response tells if there was an error; So when it's `true` that
-        #   means parse failed, and `false` means parse was successful.
-        #   case of success.
-        return self unless @parser.parse(@state, data)
-
-        raise IOError, "Could not parse data"
+      def reset
+        @parser.finish
+        @handler.reset
+        @header_finished = false
+        @message_finished = false
+        @headers = Headers.new
+        @chunk = nil
+        @status_code = nil
+        @http_version = nil
       end
-      alias << add
 
-      def headers?
-        @finished[:headers]
-      end
+      def add(data)
+        parser << data
 
-      def http_version
-        @state.http_version
+        self
+      rescue LLHttp::Error => e
+        raise IOError, e.message
       end
 
-      def status_code
-        @state.http_status
+      alias << add
+
+      def mark_header_finished
+        @header_finished = true
+        @status_code = @parser.status_code
+        @http_version = "#{@parser.http_major}.#{@parser.http_minor}"
       end
 
-      #
-      # HTTP::Parser callbacks
-      #
+      def headers?
+        @header_finished
+      end
 
-      def on_header_field(_response, field)
-        append_header if @reading_header_value
-        @field << field
+      def add_header(name, value)
+        @headers.add(name, value)
       end
 
-      def on_header_value(_response, value)
-        @reading_header_value = true
-        @field_value << value
+      def mark_message_finished
+        @message_finished = true
       end
 
-      def on_headers_complete(_reposse)
-        append_header if @reading_header_value
-        @finished[:headers] = true
+      def finished?
+        @message_finished
       end
 
-      def on_body(_response, chunk)
+      def add_body(chunk)
         if @chunk
           @chunk << chunk
         else
@@ -85,32 +79,50 @@ module HTTP
         chunk
       end
 
-      def on_message_complete(_response)
-        @finished[:message] = true
-      end
+      class Handler < LLHttp::Delegate
+        def initialize(target)
+          @target = target
+          super()
+          reset
+        end
 
-      def reset
-        @state.reset!
-
-        @finished             = Hash.new(false)
-        @headers              = HTTP::Headers.new
-        @reading_header_value = false
-        @field                = +""
-        @field_value          = +""
-        @chunk                = nil
-      end
+        def reset
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
 
-      def finished?
-        @finished[:message]
-      end
+        def on_header_field(field)
+          append_header if @reading_header_value
+          @field << field
+        end
+
+        def on_header_value(value)
+          @reading_header_value = true
+          @field_value << value
+        end
 
-      private
+        def on_headers_complete
+          append_header if @reading_header_value
+          @target.mark_header_finished
+        end
+
+        def on_body(body)
+          @target.add_body(body)
+        end
 
-      def append_header
-        @headers.add(@field, @field_value)
-        @reading_header_value = false
-        @field_value          = +""
-        @field                = +""
+        def on_message_complete
+          @target.mark_message_finished
+        end
+
+        private
+
+        def append_header
+          @target.add_header(@field, @field_value)
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
       end
     end
   end