http 4.4.1 → 5.1.0

data/lib/http/content_type.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module HTTP
-  ContentType = Struct.new(:mime_type, :charset) do
-    MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}
-    CHARSET_RE   = /;\s*charset=([^;]+)/i
+  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
@@ -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/errors.rb

@@ -19,6 +19,9 @@ module HTTP
   # Generic Timeout error
   class TimeoutError < Error; end
 
+  # Timeout when first establishing the conncetion
+  class ConnectTimeoutError < TimeoutError; end
+
   # Header value is of unexpected format (similar to Net::HTTPHeaderSyntaxError)
   class HeaderError < Error; 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
 
@@ -13,6 +13,8 @@ module HTTP
     def wrap_response(response)
       response
     end
+
+    def on_error(request, error); end
   end
 end
 

data/lib/http/features/auto_deflate.rb

@@ -27,12 +27,12 @@ module HTTP
         request.headers[Headers::CONTENT_ENCODING] = method
 
         Request.new(
-          :version => request.version,
-          :verb => request.verb,
-          :uri => request.uri,
-          :headers => request.headers,
-          :proxy => request.proxy,
-          :body => deflated_body(request.body),
+          :version        => request.version,
+          :verb           => request.verb,
+          :uri            => request.uri,
+          :headers        => request.headers,
+          :proxy          => request.proxy,
+          :body           => deflated_body(request.body),
           :uri_normalizer => request.uri_normalizer
         )
       end

data/lib/http/features/auto_inflate.rb

@@ -12,16 +12,15 @@ module HTTP
         return response unless supported_encoding?(response)
 
         options = {
-          :status => response.status,
-          :version => response.version,
-          :headers => response.headers,
+          :status        => response.status,
+          :version       => response.version,
+          :headers       => response.headers,
           :proxy_headers => response.proxy_headers,
-          :connection => response.connection,
-          :body => stream_for(response.connection)
+          :connection    => response.connection,
+          :body          => stream_for(response.connection),
+          :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

@@ -13,14 +13,18 @@ module HTTP
     include Enumerable
 
     # Matches HTTP header names when in "Canonical-Http-Format"
-    CANONICAL_NAME_RE = /^[A-Z][a-z]*(?:-[A-Z][a-z]*)*$/
+    CANONICAL_NAME_RE = /\A[A-Z][a-z]*(?:-[A-Z][a-z]*)*\z/.freeze
 
     # Matches valid header field name according to RFC.
     # @see http://tools.ietf.org/html/rfc7230#section-3.2
-    COMPLIANT_NAME_RE = /^[A-Za-z0-9!#\$%&'*+\-.^_`|~]+$/
+    COMPLIANT_NAME_RE = /\A[A-Za-z0-9!#$%&'*+\-.^_`|~]+\z/.freeze
 
     # Class constructor.
     def initialize
+      # The @pile stores each header value using a three element array:
+      #  0 - the normalized header key, used for lookup
+      #  1 - the header key as it will be sent with a request
+      #  2 - the value
       @pile = []
     end
 
@@ -45,12 +49,31 @@ module HTTP
 
     # Appends header.
     #
-    # @param [#to_s] name header name
+    # @param [String, Symbol] name header name. When specified as a string, the
+    #   name is sent as-is. When specified as a symbol, the name is converted
+    #   to a string of capitalized words separated by a dash. Word boundaries
+    #   are determined by an underscore (`_`) or a dash (`-`).
+    #   Ex: `:content_type` is sent as `"Content-Type"`, and `"auth_key"` (string)
+    #   is sent as `"auth_key"`.
     # @param [Array<#to_s>, #to_s] value header value(s) to be appended
     # @return [void]
     def add(name, value)
-      name = normalize_header name.to_s
-      Array(value).each { |v| @pile << [name, v.to_s] }
+      lookup_name = normalize_header(name.to_s)
+      wire_name = case name
+                  when String
+                    name
+                  when Symbol
+                    lookup_name
+                  else
+                    raise HTTP::HeaderError, "HTTP header must be a String or Symbol: #{name.inspect}"
+                  end
+      Array(value).each do |v|
+        @pile << [
+          lookup_name,
+          wire_name,
+          validate_value(v)
+        ]
+      end
     end
 
     # Returns list of header values if any.
@@ -58,7 +81,7 @@ module HTTP
     # @return [Array<String>]
     def get(name)
       name = normalize_header name.to_s
-      @pile.select { |k, _| k == name }.map { |_, v| v }
+      @pile.select { |k, _| k == name }.map { |_, _, v| v }
     end
 
     # Smart version of {#get}.
@@ -88,7 +111,7 @@ module HTTP
     #
     # @return [Hash]
     def to_h
-      Hash[keys.map { |k| [k, self[k]] }]
+      keys.to_h { |k| [k, self[k]] }
     end
     alias to_hash to_h
 
@@ -96,7 +119,7 @@ module HTTP
     #
     # @return [Array<[String, String]>]
     def to_a
-      @pile.map { |pair| pair.map(&:dup) }
+      @pile.map { |item| item[1..2] }
     end
 
     # Returns human-readable representation of `self` instance.
@@ -110,7 +133,7 @@ module HTTP
     #
     # @return [Array<String>]
     def keys
-      @pile.map { |k, _| k }.uniq
+      @pile.map { |_, k, _| k }.uniq
     end
 
     # Compares headers to another Headers or Array of key/value pairs
@@ -118,7 +141,8 @@ module HTTP
     # @return [Boolean]
     def ==(other)
       return false unless other.respond_to? :to_a
-      @pile == other.to_a
+
+      to_a == other.to_a
     end
 
     # Calls the given block once for each key/value pair in headers container.
@@ -127,7 +151,8 @@ module HTTP
     # @return [Headers] self-reference
     def each
       return to_enum(__method__) unless block_given?
-      @pile.each { |arr| yield(arr) }
+
+      @pile.each { |item| yield(item[1..2]) }
       self
     end
 
@@ -139,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]
@@ -150,7 +175,7 @@ module HTTP
     # @api private
     def initialize_copy(orig)
       super
-      @pile = to_a
+      @pile = @pile.map(&:dup)
     end
 
     # Merges `other` headers into `self`.
@@ -209,5 +234,17 @@ module HTTP
 
       raise HeaderError, "Invalid HTTP header field name: #{name.inspect}"
     end
+
+    # Ensures there is no new line character in the header value
+    #
+    # @param [String] value
+    # @raise [HeaderError] if value includes new line character
+    # @return [String] stringified header value
+    def validate_value(value)
+      v = value.to_s
+      return v unless v.include?("\n")
+
+      raise HeaderError, "Invalid HTTP header field value: #{v.inspect}"
+    end
   end
 end

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
@@ -49,6 +49,8 @@ module HTTP
       @request  = request
       @response = response
       @visited  = []
+      collect_cookies_from_request
+      collect_cookies_from_response
 
       while REDIRECT_CODES.include? @response.status.code
         @visited << "#{@request.verb} #{@request.uri}"
@@ -59,8 +61,12 @@ module HTTP
         @response.flush
 
         # XXX(ixti): using `Array#inject` to return `nil` if no Location header.
-        @request  = redirect_to(@response.headers.get(Headers::LOCATION).inject(:+))
+        @request = redirect_to(@response.headers.get(Headers::LOCATION).inject(:+))
+        unless cookie_jar.empty?
+          @request.headers.set(Headers::COOKIE, cookie_jar.cookies.map { |c| "#{c.name}=#{c.value}" }.join("; "))
+        end
         @response = yield @request
+        collect_cookies_from_response
       end
 
       @response
@@ -68,6 +74,48 @@ module HTTP
 
     private
 
+    # All known cookies. On the original request, this is only the original cookies, but after that,
+    # Set-Cookie headers can add, set or delete cookies.
+    def cookie_jar
+      # it seems that @response.cookies instance is reused between responses, so we have to "clone"
+      @cookie_jar ||= HTTP::CookieJar.new
+    end
+
+    def collect_cookies_from_request
+      request_cookie_header = @request.headers["Cookie"]
+      cookies =
+        if request_cookie_header
+          HTTP::Cookie.cookie_value_to_hash(request_cookie_header)
+        else
+          {}
+        end
+
+      cookies.each do |key, value|
+        cookie_jar.add(HTTP::Cookie.new(key, value, :path => @request.uri.path, :domain => @request.host))
+      end
+    end
+
+    # Carry cookies from one response to the next. Carrying cookies to the next response ends up
+    # carrying them to the next request as well.
+    #
+    # Note that this isn't part of the IETF standard, but all major browsers support setting cookies
+    # on redirect: https://blog.dubbelboer.com/2012/11/25/302-cookie.html
+    def collect_cookies_from_response
+      # Overwrite previous cookies
+      @response.cookies.each do |cookie|
+        if cookie.value == ""
+          cookie_jar.delete(cookie)
+        else
+          cookie_jar.add(cookie)
+        end
+      end
+
+      # I wish we could just do @response.cookes = cookie_jar
+      cookie_jar.each do |cookie|
+        @response.cookies.add(cookie)
+      end
+    end
+
     # Check if we reached max amount of redirect hops
     # @return [Boolean]
     def too_many_hops?
@@ -90,6 +138,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/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

@@ -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.
@@ -108,12 +112,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/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/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
@@ -64,6 +65,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