http 2.2.2 → 3.0.0.pre

data/lib/http/options.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength, Style/RedundantSelf
+
 require "http/headers"
 require "openssl"
 require "socket"
@@ -8,7 +11,6 @@ require "http/features/auto_inflate"
 require "http/features/auto_deflate"
 
 module HTTP
-  # rubocop:disable Metrics/ClassLength
   class Options
     @default_socket_class     = TCPSocket
     @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
@@ -22,7 +24,7 @@ module HTTP
       attr_accessor :default_socket_class, :default_ssl_socket_class, :default_timeout_class
       attr_reader :available_features
 
-      def new(options = {})
+      def new(options = {}) # rubocop:disable Style/OptionHash
         return options if options.is_a?(self)
         super
       end
@@ -46,7 +48,7 @@ module HTTP
       end
     end
 
-    def initialize(options = {})
+    def initialize(options = {}) # rubocop:disable Style/OptionHash
       defaults = {
         :response           => :auto,
         :proxy              => {},
@@ -115,21 +117,22 @@ module HTTP
       end
     end
 
-    %w(
+    %w[
       proxy params form json body follow response
       socket_class nodelay ssl_socket_class ssl_context ssl
       persistent keep_alive_timeout timeout_class timeout_options
-    ).each do |method_name|
+    ].each do |method_name|
       def_option method_name
     end
 
     def follow=(value)
-      @follow = case
-                when !value                    then nil
-                when true == value             then {}
-                when value.respond_to?(:fetch) then value
-                else argument_error! "Unsupported follow options: #{value}"
-                end
+      @follow =
+        case
+        when !value                    then nil
+        when true == value             then {}
+        when value.respond_to?(:fetch) then value
+        else argument_error! "Unsupported follow options: #{value}"
+        end
     end
 
     def persistent=(value)
@@ -182,7 +185,7 @@ module HTTP
     private
 
     def argument_error!(message)
-      raise(Error, message, caller[1..-1])
+      raise(Error, message, caller(1..-1))
     end
   end
 end

data/lib/http/redirector.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 require "http/headers"
@@ -20,10 +21,10 @@ module HTTP
 
     # Insecure http verbs, which should trigger StateError in strict mode
     # upon {STRICT_SENSITIVE_CODES}
-    UNSAFE_VERBS = [:put, :delete, :post].to_set.freeze
+    UNSAFE_VERBS = %i[put delete post].to_set.freeze
 
     # Verbs which will remain unchanged upon See Other response.
-    SEE_OTHER_ALLOWED_VERBS = [:get, :head].to_set.freeze
+    SEE_OTHER_ALLOWED_VERBS = %i[get head].to_set.freeze
 
     # @!attribute [r] strict
     #   Returns redirector policy.
@@ -38,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 = {})
+    def initialize(opts = {}) # rubocop:disable Style/OptionHash
       @strict   = opts.fetch(:strict, true)
       @max_hops = opts.fetch(:max_hops, 5).to_i
     end

data/lib/http/request.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+
 require "forwardable"
 require "base64"
 require "time"
 
 require "http/errors"
 require "http/headers"
+require "http/request/body"
 require "http/request/writer"
 require "http/version"
 require "http/uri"
@@ -22,7 +24,7 @@ module HTTP
     class UnsupportedSchemeError < RequestError; end
 
     # Default User-Agent header value
-    USER_AGENT = "http.rb/#{HTTP::VERSION}".freeze
+    USER_AGENT = "http.rb/#{HTTP::VERSION}"
 
     METHODS = [
       # RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
@@ -48,7 +50,7 @@ module HTTP
     ].freeze
 
     # Allowed schemes
-    SCHEMES = [:http, :https, :ws, :wss].freeze
+    SCHEMES = %i[http https ws wss].freeze
 
     # Default ports of supported schemes
     PORTS = {
@@ -74,7 +76,7 @@ module HTTP
     # @option opts [HTTP::URI, #to_s] :uri
     # @option opts [Hash] :headers
     # @option opts [Hash] :proxy
-    # @option opts [String] :body
+    # @option opts [String, Enumerable, IO, nil] :body
     def initialize(opts)
       @verb   = opts.fetch(:verb).to_s.downcase.to_sym
       @uri    = normalize_uri(opts.fetch(:uri))
@@ -84,7 +86,7 @@ module HTTP
       raise(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
 
       @proxy   = opts[:proxy] || {}
-      @body    = opts[:body]
+      @body    = request_body(opts[:body], opts)
       @version = opts[:version] || "1.1"
       @headers = HTTP::Headers.coerce(opts[:headers] || {})
 
@@ -94,7 +96,10 @@ module HTTP
 
     # Returns new Request with updated uri
     def redirect(uri, verb = @verb)
-      req = self.class.new(
+      headers = self.headers.dup
+      headers.delete(Headers::HOST)
+
+      self.class.new(
         :verb    => verb,
         :uri     => @uri.join(uri),
         :headers => headers,
@@ -102,9 +107,6 @@ module HTTP
         :body    => body,
         :version => version
       )
-
-      req[Headers::HOST] = req.uri.host
-      req
     end
 
     # Stream the request to a socket
@@ -145,8 +147,14 @@ module HTTP
 
     # Compute HTTP request header for direct or proxy request
     def headline
-      request_uri = (using_proxy? && !uri.https?) ? uri : uri.omit(:scheme, :authority)
-      "#{verb.to_s.upcase} #{request_uri.omit :fragment} HTTP/#{version}"
+      request_uri =
+        if using_proxy? && !uri.https?
+          uri.omit(:fragment)
+        else
+          uri.omit(:scheme, :authority, :fragment)
+        end
+
+      "#{verb.to_s.upcase} #{request_uri} HTTP/#{version}"
     end
 
     # Compute HTTP request header SSL proxy connection
@@ -178,6 +186,13 @@ module HTTP
 
     private
 
+    # Transforms body to an object suitable for streaming.
+    def request_body(body, opts)
+      body = Request::Body.new(body) unless body.is_a?(Request::Body)
+      body = opts[:auto_deflate].deflated_body(body) if opts[:auto_deflate]
+      body
+    end
+
     # @!attribute [r] host
     #   @return [String]
     def_delegator :@uri, :host

data/lib/http/request/body.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Request
+    class Body
+      def initialize(body)
+        @body = body
+
+        validate_body_type!
+      end
+
+      # Returns size which should be used for the "Content-Length" header.
+      #
+      # @return [Integer]
+      def size
+        if @body.is_a?(String)
+          @body.bytesize
+        elsif @body.respond_to?(:read)
+          raise RequestError, "IO object must respond to #size" unless @body.respond_to?(:size)
+          @body.size
+        elsif @body.nil?
+          0
+        else
+          raise RequestError, "cannot determine size of body: #{@body.inspect}"
+        end
+      end
+
+      # Yields chunks of content to be streamed to the request body.
+      #
+      # @yieldparam [String]
+      def each(&block)
+        if @body.is_a?(String)
+          yield @body
+        elsif @body.respond_to?(:read)
+          IO.copy_stream(@body, ProcIO.new(block))
+        elsif @body.is_a?(Enumerable)
+          @body.each(&block)
+        end
+      end
+
+      private
+
+      def validate_body_type!
+        return if @body.is_a?(String)
+        return if @body.respond_to?(:read)
+        return if @body.is_a?(Enumerable)
+        return if @body.nil?
+
+        raise RequestError, "body of wrong type: #{@body.class}"
+      end
+
+      # This class provides a "writable IO" wrapper around a proc object, with
+      # #write simply calling the proc, which we can pass in as the
+      # "destination IO" in IO.copy_stream.
+      class ProcIO
+        def initialize(block)
+          @block = block
+        end
+
+        def write(data)
+          @block.call(data)
+          data.bytesize
+        end
+      end
+    end
+  end
+end

data/lib/http/request/writer.rb

@@ -1,31 +1,27 @@
 # frozen_string_literal: true
+
 require "http/headers"
 
 module HTTP
   class Request
     class Writer
       # CRLF is the universal HTTP delimiter
-      CRLF = "\r\n".freeze
+      CRLF = "\r\n"
 
       # Chunked data termintaor.
-      ZERO = "0".freeze
+      ZERO = "0"
 
       # Chunked transfer encoding
-      CHUNKED = "chunked".freeze
+      CHUNKED = "chunked"
 
       # End of a chunked transfer
-      CHUNKED_END = "#{ZERO}#{CRLF}#{CRLF}".freeze
-
-      # Types valid to be used as body source
-      VALID_BODY_TYPES = [String, NilClass, Enumerable].freeze
+      CHUNKED_END = "#{ZERO}#{CRLF}#{CRLF}"
 
       def initialize(socket, body, headers, headline)
         @body           = body
         @socket         = socket
         @headers        = headers
         @request_header = [headline]
-
-        validate_body_type!
       end
 
       # Adds headers to the request header from the headers array
@@ -51,13 +47,9 @@ module HTTP
       # Adds the headers to the header array for the given request body we are working
       # with
       def add_body_type_headers
-        if @body.is_a?(String) && !@headers[Headers::CONTENT_LENGTH]
-          @request_header << "#{Headers::CONTENT_LENGTH}: #{@body.bytesize}"
-        elsif @body.nil? && !@headers[Headers::CONTENT_LENGTH]
-          @request_header << "#{Headers::CONTENT_LENGTH}: 0"
-        elsif @body.is_a?(Enumerable) && CHUNKED != @headers[Headers::TRANSFER_ENCODING]
-          raise(RequestError, "invalid transfer encoding")
-        end
+        return if @headers[Headers::CONTENT_LENGTH] || chunked?
+
+        @request_header << "#{Headers::CONTENT_LENGTH}: #{@body.size}"
       end
 
       # Joins the headers specified in the request into a correctly formatted
@@ -69,29 +61,37 @@ module HTTP
       end
 
       def send_request
-        headers = join_headers
-
         # It's important to send the request in a single write call when
         # possible in order to play nicely with Nagle's algorithm. Making
         # two writes in a row triggers a pathological case where Nagle is
         # expecting a third write that never happens.
-        case @body
-        when NilClass
-          write(headers)
-        when String
-          write(headers << @body)
-        when Enumerable
-          write(headers)
-
-          @body.each do |chunk|
-            write(chunk.bytesize.to_s(16) << CRLF << chunk << CRLF)
-          end
-
-          write(CHUNKED_END)
-        else raise TypeError, "invalid body type: #{@body.class}"
+        data = join_headers
+
+        @body.each do |chunk|
+          data << encode_chunk(chunk)
+          write(data)
+          data.clear
+        end
+
+        write(data) unless data.empty?
+
+        write(CHUNKED_END) if chunked?
+      end
+
+      # Returns the chunk encoded for to the specified "Transfer-Encoding" header.
+      def encode_chunk(chunk)
+        if chunked?
+          chunk.bytesize.to_s(16) << CRLF << chunk << CRLF
+        else
+          chunk
         end
       end
 
+      # Returns true if the request should be sent in chunked encoding.
+      def chunked?
+        @headers[Headers::TRANSFER_ENCODING] == CHUNKED
+      end
+
       private
 
       def write(data)
@@ -101,11 +101,6 @@ module HTTP
           data = data.byteslice(length..-1)
         end
       end
-
-      def validate_body_type!
-        return if VALID_BODY_TYPES.any? { |type| @body.is_a? type }
-        raise RequestError, "body of wrong type: #{@body.class}"
-      end
     end
   end
 end

data/lib/http/response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "forwardable"
 
 require "http/headers"
@@ -50,7 +51,7 @@ module HTTP
         encoding   = opts[:encoding] || charset || Encoding::BINARY
         stream     = body_stream_for(connection, opts)
 
-        @body = Response::Body.new(stream, encoding)
+        @body = Response::Body.new(stream, :encoding => encoding)
       else
         @body = opts.fetch(:body)
       end
@@ -98,8 +99,13 @@ module HTTP
     #   (not an integer, e.g. empty string or string with non-digits).
     # @return [Integer] otherwise
     def content_length
+      # http://greenbytes.de/tech/webdav/rfc7230.html#rfc.section.3.3.3
+      # Clause 3: "If a message is received with both a Transfer-Encoding
+      # and a Content-Length header field, the Transfer-Encoding overrides the Content-Length.
+      return nil if @headers.include?(Headers::TRANSFER_ENCODING)
+
       value = @headers[Headers::CONTENT_LENGTH]
-      return unless value
+      return nil unless value
 
       begin
         Integer(value)
@@ -131,6 +137,15 @@ module HTTP
       end
     end
 
+    def chunked?
+      return false unless @headers.include?(Headers::TRANSFER_ENCODING)
+
+      encoding = @headers.get(Headers::TRANSFER_ENCODING)
+
+      # TODO: "chunked" is frozen in the request writer. How about making it accessible?
+      encoding.last == "chunked"
+    end
+
     # Parse response body with corresponding MIME type adapter.
     #
     # @param [#to_s] as Parse as given MIME type

data/lib/http/response/body.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "forwardable"
 require "http/client"
 
@@ -15,18 +16,19 @@ module HTTP
       # @return [HTTP::Connection]
       attr_reader :connection
 
-      def initialize(stream, encoding = Encoding::BINARY)
+      def initialize(stream, encoding: Encoding::BINARY)
         @stream     = stream
         @connection = stream.is_a?(Inflater) ? stream.connection : stream
         @streaming  = nil
         @contents   = nil
-        @encoding   = encoding
+        @encoding   = find_encoding(encoding)
       end
 
       # (see HTTP::Client#readpartial)
       def readpartial(*args)
         stream!
-        @stream.readpartial(*args)
+        chunk = @stream.readpartial(*args)
+        chunk.force_encoding(@encoding) if chunk
       end
 
       # Iterate over the body, allowing it to be enumerable
@@ -42,19 +44,12 @@ module HTTP
 
         raise StateError, "body is being streamed" unless @streaming.nil?
 
-        # see issue 312
-        begin
-          encoding = Encoding.find @encoding
-        rescue ArgumentError
-          encoding = Encoding::BINARY
-        end
-
         begin
           @streaming  = false
-          @contents   = String.new("").force_encoding(encoding)
+          @contents   = String.new("").force_encoding(@encoding)
 
           while (chunk = @stream.readpartial)
-            @contents << chunk.force_encoding(encoding)
+            @contents << chunk.force_encoding(@encoding)
           end
         rescue
           @contents = nil
@@ -75,6 +70,15 @@ module HTTP
       def inspect
         "#<#{self.class}:#{object_id.to_s(16)} @streaming=#{!!@streaming}>"
       end
+
+      private
+
+      # Retrieve encoding by name. If encoding cannot be found, default to binary.
+      def find_encoding(encoding)
+        Encoding.find encoding
+      rescue ArgumentError
+        Encoding::BINARY
+      end
     end
   end
 end