http 5.0.0.pre2 → 5.0.2

data/lib/http/connection.rb

@@ -3,7 +3,6 @@
 require "forwardable"
 
 require "http/headers"
-require "http/response/parser"
 
 module HTTP
   # A connection to the HTTP server
@@ -68,8 +67,13 @@ module HTTP
     # @param [Request] req Request to send to the server
     # @return [nil]
     def send_request(req)
-      raise StateError, "Tried to send a request while one is pending already. Make sure you read off the body." if @pending_response
-      raise StateError, "Tried to send a request while a response is pending. Make sure you read off the body."  if @pending_request
+      if @pending_response
+        raise StateError, "Tried to send a request while one is pending already. Make sure you read off the body."
+      end
+
+      if @pending_request
+        raise StateError, "Tried to send a request while a response is pending. Make sure you read off the body."
+      end
 
       @pending_request = true
 

data/lib/http/content_type.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module HTTP
-  ContentType = Struct.new(:mime_type, :charset) do
+  class ContentType
     MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}.freeze
     CHARSET_RE   = /;\s*charset=([^;]+)/i.freeze
 
+    attr_accessor :mime_type, :charset
+
     class << self
       # Parse string and return ContentType struct
       def parse(str)
@@ -15,15 +17,18 @@ module HTTP
 
       # :nodoc:
       def mime_type(str)
-        m = str.to_s[MIME_TYPE_RE, 1]
-        m && m.strip.downcase
+        str.to_s[MIME_TYPE_RE, 1]&.strip&.downcase
       end
 
       # :nodoc:
       def charset(str)
-        m = str.to_s[CHARSET_RE, 1]
-        m && m.strip.delete('"')
+        str.to_s[CHARSET_RE, 1]&.strip&.delete('"')
       end
     end
+
+    def initialize(mime_type = nil, charset = nil)
+      @mime_type = mime_type
+      @charset   = charset
+    end
   end
 end

data/lib/http/feature.rb

@@ -2,7 +2,7 @@
 
 module HTTP
   class Feature
-    def initialize(opts = {}) # rubocop:disable Style/OptionHash
+    def initialize(opts = {})
       @opts = opts
     end
 

data/lib/http/features/auto_inflate.rb

@@ -21,8 +21,6 @@ module HTTP
           :request       => response.request
         }
 
-        options[:uri] = response.uri if response.uri
-
         Response.new(options)
       end
 

data/lib/http/features/instrumentation.rb

@@ -29,7 +29,7 @@ module HTTP
       def wrap_request(request)
         # Emit a separate "start" event, so a logger can print the request
         # being run without waiting for a response
-        instrumenter.instrument("start_#{name}", :request => request) {}
+        instrumenter.instrument("start_#{name}", :request => request)
         instrumenter.start(name, :request => request)
         request
       end

data/lib/http/features/logging.rb

@@ -9,6 +9,20 @@ module HTTP
     #    HTTP.use(logging: {logger: Logger.new(STDOUT)}).get("https://example.com/")
     #
     class Logging < Feature
+      HTTP::Options.register_feature(:logging, self)
+
+      class NullLogger
+        %w[fatal error warn info debug].each do |level|
+          define_method(level.to_sym) do |*_args|
+            nil
+          end
+
+          define_method(:"#{level}?") do
+            true
+          end
+        end
+      end
+
       attr_reader :logger
 
       def initialize(logger: NullLogger.new)
@@ -17,39 +31,23 @@ module HTTP
 
       def wrap_request(request)
         logger.info { "> #{request.verb.to_s.upcase} #{request.uri}" }
-        logger.debug do
-          headers = request.headers.map { |name, value| "#{name}: #{value}" }.join("\n")
-          body = request.body.source
+        logger.debug { "#{stringify_headers(request.headers)}\n\n#{request.body.source}" }
 
-          headers + "\n\n" + body.to_s
-        end
         request
       end
 
       def wrap_response(response)
         logger.info { "< #{response.status}" }
-        logger.debug do
-          headers = response.headers.map { |name, value| "#{name}: #{value}" }.join("\n")
-          body = response.body.to_s
+        logger.debug { "#{stringify_headers(response.headers)}\n\n#{response.body}" }
 
-          headers + "\n\n" + body
-        end
         response
       end
 
-      class NullLogger
-        %w[fatal error warn info debug].each do |level|
-          define_method(level.to_sym) do |*_args|
-            nil
-          end
+      private
 
-          define_method(:"#{level}?") do
-            true
-          end
-        end
+      def stringify_headers(headers)
+        headers.map { |name, value| "#{name}: #{value}" }.join("\n")
       end
-
-      HTTP::Options.register_feature(:logging, self)
     end
   end
 end

data/lib/http/headers.rb

@@ -17,7 +17,7 @@ module HTTP
 
     # Matches valid header field name according to RFC.
     # @see http://tools.ietf.org/html/rfc7230#section-3.2
-    COMPLIANT_NAME_RE = /\A[A-Za-z0-9!#\$%&'*+\-.^_`|~]+\z/.freeze
+    COMPLIANT_NAME_RE = /\A[A-Za-z0-9!#$%&'*+\-.^_`|~]+\z/.freeze
 
     # Class constructor.
     def initialize
@@ -111,7 +111,7 @@ module HTTP
     #
     # @return [Hash]
     def to_h
-      Hash[keys.map { |k| [k, self[k]] }]
+      keys.map { |k| [k, self[k]] }.to_h
     end
     alias to_hash to_h
 
@@ -164,7 +164,7 @@ module HTTP
 
     # @!method hash
     #   Compute a hash-code for this headers container.
-    #   Two conatiners with the same content will have the same hash code.
+    #   Two containers with the same content will have the same hash code.
     #
     #   @see http://www.ruby-doc.org/core/Object.html#method-i-hash
     #   @return [Fixnum]

data/lib/http/mime_type/adapter.rb

@@ -14,6 +14,7 @@ module HTTP
         def_delegators :instance, :encode, :decode
       end
 
+      # rubocop:disable Style/DocumentDynamicEvalDefinition
       %w[encode decode].each do |operation|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{operation}(*)
@@ -21,6 +22,7 @@ module HTTP
           end
         RUBY
       end
+      # rubocop:enable Style/DocumentDynamicEvalDefinition
     end
   end
 end

data/lib/http/options.rb

@@ -32,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
@@ -47,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

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

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,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