http 4.4.0 → 5.0.0

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
@@ -168,8 +171,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 +216,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 +226,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)
+      MimeType[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,66 +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)
-        @field = field
+      def add_header(name, value)
+        @headers.add(name, value)
       end
 
-      def on_header_value(_response, value)
-        @headers.add(@field, value) if @field
+      def mark_message_finished
+        @message_finished = true
       end
 
-      def on_headers_complete(_reposse)
-        @finished[:headers] = true
+      def finished?
+        @message_finished
       end
 
-      def on_body(_response, chunk)
+      def add_body(chunk)
         if @chunk
           @chunk << chunk
         else
@@ -82,21 +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!
+        def reset
+          @reading_header_value = false
+          @field_value = +""
+          @field = +""
+        end
 
-        @finished = Hash.new(false)
-        @headers  = HTTP::Headers.new
-        @field    = nil
-        @chunk    = nil
-      end
+        def on_header_field(field)
+          append_header if @reading_header_value
+          @field << field
+        end
 
-      def finished?
-        @finished[:message]
+        def on_header_value(value)
+          @reading_header_value = true
+          @field_value << value
+        end
+
+        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 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
@@ -132,7 +132,7 @@ module HTTP
       end
 
       SYMBOLS.each do |code, symbol|
-        class_eval <<-RUBY, __FILE__, __LINE__
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{symbol}?      # def bad_request?
             #{code} == code   #   400 == code
           end                 # end
@@ -141,6 +141,7 @@ module HTTP
 
       def __setobj__(obj)
         raise TypeError, "Expected #{obj.inspect} to respond to #to_i" unless obj.respond_to? :to_i
+
         @code = obj.to_i
       end
 

data/lib/http/timeout/global.rb

@@ -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
@@ -121,9 +109,7 @@ module HTTP
 
       def log_time
         @time_left -= (Time.now - @started)
-        if @time_left <= 0
-          raise TimeoutError, "Timed out after using the allocated #{@timeout} seconds"
-        end
+        raise TimeoutError, "Timed out after using the allocated #{@timeout} seconds" if @time_left <= 0
 
         reset_timer
       end