http 5.0.0.pre3 → 5.0.3

data/lib/http/request/writer.rb

@@ -47,7 +47,11 @@ module HTTP
       # Adds the headers to the header array for the given request body we are working
       # with
       def add_body_type_headers
-        return if @headers[Headers::CONTENT_LENGTH] || chunked?
+        return if @headers[Headers::CONTENT_LENGTH] || chunked? || (
+          @body.source.nil? && %w[GET HEAD DELETE CONNECT].any? do |method|
+            @request_header[0].start_with?("#{method} ")
+          end
+        )
 
         @request_header << "#{Headers::CONTENT_LENGTH}: #{@body.size}"
       end
@@ -57,7 +61,7 @@ module HTTP
       def join_headers
         # join the headers array with crlfs, stick two on the end because
         # that ends the request header
-        @request_header.join(CRLF) + CRLF * 2
+        @request_header.join(CRLF) + (CRLF * 2)
       end
 
       # Writes HTTP request data into the socket.

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
@@ -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
       )
@@ -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/response/body.rb

@@ -28,7 +28,8 @@ module HTTP
       def readpartial(*args)
         stream!
         chunk = @stream.readpartial(*args)
-        chunk.force_encoding(@encoding) if chunk
+
+        String.new(chunk, :encoding => @encoding) if chunk
       end
 
       # Iterate over the body, allowing it to be enumerable
@@ -46,11 +47,11 @@ module HTTP
 
         begin
           @streaming  = false
-          @contents   = String.new("").force_encoding(@encoding)
+          @contents   = String.new("", :encoding => @encoding)
 
           while (chunk = @stream.readpartial)
-            @contents << chunk.force_encoding(@encoding)
-            chunk.clear # deallocate string
+            @contents << String.new(chunk, :encoding => @encoding)
+            chunk = nil # deallocate string
           end
         rescue
           @contents = nil

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.reset
+        @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,36 +79,50 @@ module HTTP
         chunk
       end
 
-      def on_message_complete(_response)
-        if @state.http_status < 200
+      class Handler < LLHttp::Delegate
+        def initialize(target)
+          @target = target
+          super()
           reset
-        else
-          @finished[:message] = true
         end
-      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

data/lib/http/response/status.rb

@@ -58,7 +58,7 @@ module HTTP
       #   SYMBOLS[418] # => :im_a_teapot
       #
       # @return [Hash<Fixnum => Symbol>]
-      SYMBOLS = Hash[REASONS.map { |k, v| [k, symbolize(v)] }].freeze
+      SYMBOLS = REASONS.transform_values { |v| symbolize(v) }.freeze
 
       # Reversed {SYMBOLS} map.
       #
@@ -69,7 +69,7 @@ module HTTP
       #   SYMBOL_CODES[:im_a_teapot]           # => 418
       #
       # @return [Hash<Symbol => Fixnum>]
-      SYMBOL_CODES = Hash[SYMBOLS.map { |k, v| [v, k] }].freeze
+      SYMBOL_CODES = SYMBOLS.map { |k, v| [v, k] }.to_h.freeze
 
       # @return [Fixnum] status code
       attr_reader :code

data/lib/http/response.rb

@@ -40,10 +40,11 @@ module HTTP
     # @option opts [HTTP::Connection] :connection
     # @option opts [String] :encoding Encoding to use when reading body
     # @option opts [String] :body
-    # @option opts [HTTP::Request] request
+    # @option opts [HTTP::Request] request The request this is in response to.
+    # @option opts [String] :uri (DEPRECATED) used to populate a missing request
     def initialize(opts)
       @version       = opts.fetch(:version)
-      @request       = opts.fetch(:request)
+      @request       = init_request(opts)
       @status        = HTTP::Response::Status.new(opts.fetch(:status))
       @headers       = HTTP::Headers.coerce(opts[:headers] || {})
       @proxy_headers = HTTP::Headers.coerce(opts[:proxy_headers] || {})
@@ -137,8 +138,8 @@ module HTTP
     def_delegator :content_type, :charset
 
     def cookies
-      @cookies ||= headers.each_with_object CookieJar.new do |(k, v), jar|
-        jar.parse(v, uri) if k == Headers::SET_COOKIE
+      @cookies ||= headers.get(Headers::SET_COOKIE).each_with_object CookieJar.new do |v, jar|
+        jar.parse(v, uri)
       end
     end
 
@@ -156,13 +157,30 @@ module HTTP
     # @param type [#to_s] Parse as given MIME type.
     # @raise (see MimeType.[])
     # @return [Object]
-    def parse(type)
-      MimeType[type].decode to_s
+    def parse(type = nil)
+      MimeType[type || mime_type].decode to_s
     end
 
     # Inspect a response
     def inspect
       "#<#{self.class}/#{@version} #{code} #{reason} #{headers.to_h.inspect}>"
     end
+
+    private
+
+    # Initialize an HTTP::Request from options.
+    #
+    # @return [HTTP::Request]
+    def init_request(opts)
+      raise ArgumentError, ":uri is for backwards compatibilty and conflicts with :request" \
+        if opts[:request] && opts[:uri]
+
+      # For backwards compatibilty
+      if opts[:uri]
+        HTTP::Request.new(:uri => opts[:uri], :verb => :get)
+      else
+        opts.fetch(:request)
+      end
+    end
   end
 end

data/lib/http/timeout/global.rb

@@ -35,11 +35,11 @@ module HTTP
         begin
           @socket.connect_nonblock
         rescue IO::WaitReadable
-          IO.select([@socket], nil, nil, @time_left)
+          @socket.wait_readable(@time_left)
           log_time
           retry
         rescue IO::WaitWritable
-          IO.select(nil, [@socket], nil, @time_left)
+          @socket.wait_writable(@time_left)
           log_time
           retry
         end
@@ -59,22 +59,12 @@ module HTTP
 
       private
 
-      if RUBY_VERSION < "2.1.0"
-        def read_nonblock(size, buffer = nil)
-          @socket.read_nonblock(size, buffer)
-        end
-
-        def write_nonblock(data)
-          @socket.write_nonblock(data)
-        end
-      else
-        def read_nonblock(size, buffer = nil)
-          @socket.read_nonblock(size, buffer, :exception => false)
-        end
+      def read_nonblock(size, buffer = nil)
+        @socket.read_nonblock(size, buffer, :exception => false)
+      end
 
-        def write_nonblock(data)
-          @socket.write_nonblock(data, :exception => false)
-        end
+      def write_nonblock(data)
+        @socket.write_nonblock(data, :exception => false)
       end
 
       # Perform the given I/O operation with the given argument
@@ -82,20 +72,18 @@ module HTTP
         reset_timer
 
         loop do
-          begin
-            result = yield
-
-            case result
-            when :wait_readable then wait_readable_or_timeout
-            when :wait_writable then wait_writable_or_timeout
-            when NilClass       then return :eof
-            else                return result
-            end
-          rescue IO::WaitReadable
-            wait_readable_or_timeout
-          rescue IO::WaitWritable
-            wait_writable_or_timeout
+          result = yield
+
+          case result
+          when :wait_readable then wait_readable_or_timeout
+          when :wait_writable then wait_writable_or_timeout
+          when NilClass       then return :eof
+          else                return result
           end
+        rescue IO::WaitReadable
+          wait_readable_or_timeout
+        rescue IO::WaitWritable
+          wait_writable_or_timeout
         end
       rescue EOFError
         :eof

data/lib/http/timeout/null.rb

@@ -12,7 +12,7 @@ module HTTP
 
       attr_reader :options, :socket
 
-      def initialize(options = {}) # rubocop:disable Style/OptionHash
+      def initialize(options = {})
         @options = options
       end
 
@@ -36,6 +36,7 @@ module HTTP
         connect_ssl
 
         return unless ssl_context.verify_mode == OpenSSL::SSL::VERIFY_PEER
+        return if ssl_context.respond_to?(:verify_hostname) && !ssl_context.verify_hostname
 
         @socket.post_connection_check(host)
       end

data/lib/http/timeout/per_operation.rb

@@ -34,66 +34,42 @@ module HTTP
         end
       end
 
-      # NIO with exceptions
-      if RUBY_VERSION < "2.1.0"
-        # Read data from the socket
-        def readpartial(size, buffer = nil)
-          rescue_readable do
-            @socket.read_nonblock(size, buffer)
-          end
-        rescue EOFError
-          :eof
-        end
-
-        # Write data to the socket
-        def write(data)
-          rescue_writable do
-            @socket.write_nonblock(data)
-          end
-        rescue EOFError
-          :eof
-        end
-
-      # NIO without exceptions
-      else
-        # Read data from the socket
-        def readpartial(size, buffer = nil)
-          timeout = false
-          loop do
-            result = @socket.read_nonblock(size, buffer, :exception => false)
-
-            return :eof   if result.nil?
-            return result if result != :wait_readable
-
-            raise TimeoutError, "Read timed out after #{@read_timeout} seconds" if timeout
-
-            # marking the socket for timeout. Why is this not being raised immediately?
-            # it seems there is some race-condition on the network level between calling
-            # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
-            # for reads, and when waiting for x seconds, it returns nil suddenly without completing
-            # the x seconds. In a normal case this would be a timeout on wait/read, but it can
-            # also mean that the socket has been closed by the server. Therefore we "mark" the
-            # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
-            # timeout. Else, the first timeout was a proper timeout.
-            # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
-            # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
-            timeout = true unless @socket.to_io.wait_readable(@read_timeout)
-          end
+      # Read data from the socket
+      def readpartial(size, buffer = nil)
+        timeout = false
+        loop do
+          result = @socket.read_nonblock(size, buffer, :exception => false)
+
+          return :eof   if result.nil?
+          return result if result != :wait_readable
+
+          raise TimeoutError, "Read timed out after #{@read_timeout} seconds" if timeout
+
+          # marking the socket for timeout. Why is this not being raised immediately?
+          # it seems there is some race-condition on the network level between calling
+          # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
+          # for reads, and when waiting for x seconds, it returns nil suddenly without completing
+          # the x seconds. In a normal case this would be a timeout on wait/read, but it can
+          # also mean that the socket has been closed by the server. Therefore we "mark" the
+          # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
+          # timeout. Else, the first timeout was a proper timeout.
+          # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
+          # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
+          timeout = true unless @socket.to_io.wait_readable(@read_timeout)
         end
+      end
 
-        # Write data to the socket
-        def write(data)
-          timeout = false
-          loop do
-            result = @socket.write_nonblock(data, :exception => false)
-            return result unless result == :wait_writable
+      # Write data to the socket
+      def write(data)
+        timeout = false
+        loop do
+          result = @socket.write_nonblock(data, :exception => false)
+          return result unless result == :wait_writable
 
-            raise TimeoutError, "Write timed out after #{@write_timeout} seconds" if timeout
+          raise TimeoutError, "Write timed out after #{@write_timeout} seconds" if timeout
 
-            timeout = true unless @socket.to_io.wait_writable(@write_timeout)
-          end
+          timeout = true unless @socket.to_io.wait_writable(@write_timeout)
         end
-
       end
     end
   end

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "5.0.0.pre3"
+  VERSION = "5.0.3"
 end