http 3.3.0 → 4.0.0

data/lib/http/options.rb

@@ -1,24 +1,18 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength, Style/RedundantSelf
+# rubocop:disable Metrics/ClassLength
 
 require "http/headers"
 require "openssl"
 require "socket"
 require "http/uri"
-require "http/feature"
-require "http/features/auto_inflate"
-require "http/features/auto_deflate"
 
 module HTTP
   class Options
     @default_socket_class     = TCPSocket
     @default_ssl_socket_class = OpenSSL::SSL::SSLSocket
     @default_timeout_class    = HTTP::Timeout::Null
-    @available_features       = {
-      :auto_inflate => Features::AutoInflate,
-      :auto_deflate => Features::AutoDeflate
-    }
+    @available_features       = {}
 
     class << self
       attr_accessor :default_socket_class, :default_ssl_socket_class, :default_timeout_class
@@ -33,14 +27,22 @@ module HTTP
         @defined_options ||= []
       end
 
+      def register_feature(name, impl)
+        @available_features[name] = impl
+      end
+
       protected
 
-      def def_option(name, &interpreter)
+      def def_option(name, reader_only: false, &interpreter)
         defined_options << name.to_sym
         interpreter ||= lambda { |v| v }
 
-        attr_accessor name
-        protected :"#{name}="
+        if reader_only
+          attr_reader name
+        else
+          attr_accessor name
+          protected :"#{name}="
+        end
 
         define_method(:"with_#{name}") do |value|
           dup { |opts| opts.send(:"#{name}=", instance_exec(value, &interpreter)) }
@@ -70,12 +72,12 @@ module HTTP
       opts_w_defaults.each { |(k, v)| self[k] = v }
     end
 
-    def_option :headers do |headers|
-      self.headers.merge(headers)
+    def_option :headers do |new_headers|
+      headers.merge(new_headers)
     end
 
-    def_option :cookies do |cookies|
-      cookies.each_with_object self.cookies.dup do |(k, v), jar|
+    def_option :cookies do |new_cookies|
+      new_cookies.each_with_object cookies.dup do |(k, v), jar|
         cookie = k.is_a?(Cookie) ? k : Cookie.new(k.to_s, v.to_s)
         jar[cookie.name] = cookie.cookie_value
       end
@@ -85,7 +87,7 @@ module HTTP
       self.encoding = Encoding.find(encoding)
     end
 
-    def_option :features do |features|
+    def_option :features, :reader_only => true do |new_features|
       # Normalize features from:
       #
       #     [{feature_one: {opt: 'val'}}, :feature_two]
@@ -93,7 +95,7 @@ module HTTP
       # into:
       #
       #     {feature_one: {opt: 'val'}, feature_two: {}}
-      features = features.each_with_object({}) do |feature, h|
+      normalized_features = new_features.each_with_object({}) do |feature, h|
         if feature.is_a?(Hash)
           h.merge!(feature)
         else
@@ -101,7 +103,7 @@ module HTTP
         end
       end
 
-      self.features.merge(features)
+      features.merge(normalized_features)
     end
 
     def features=(features)
@@ -118,13 +120,15 @@ module HTTP
     end
 
     %w[
-      proxy params form json body follow response
+      proxy params form json body response
       socket_class nodelay ssl_socket_class ssl_context ssl
-      persistent keep_alive_timeout timeout_class timeout_options
+      keep_alive_timeout timeout_class timeout_options
     ].each do |method_name|
       def_option method_name
     end
 
+    def_option :follow, :reader_only => true
+
     def follow=(value)
       @follow =
         case
@@ -135,6 +139,8 @@ module HTTP
         end
     end
 
+    def_option :persistent, :reader_only => true
+
     def persistent=(value)
       @persistent = value ? HTTP::URI.parse(value).origin : nil
     end

data/lib/http/request.rb

@@ -86,7 +86,7 @@ module HTTP
       raise(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
 
       @proxy   = opts[:proxy] || {}
-      @body    = request_body(opts[:body], opts)
+      @body    = (body = opts[:body]).is_a?(Request::Body) ? body : Request::Body.new(body)
       @version = opts[:version] || "1.1"
       @headers = HTTP::Headers.coerce(opts[:headers] || {})
 
@@ -100,12 +100,12 @@ module HTTP
       headers.delete(Headers::HOST)
 
       self.class.new(
-        :verb    => verb,
-        :uri     => @uri.join(uri),
-        :headers => headers,
-        :proxy   => proxy,
-        :body    => body,
-        :version => version
+        :verb         => verb,
+        :uri          => @uri.join(uri),
+        :headers      => headers,
+        :proxy        => proxy,
+        :body         => body.source,
+        :version      => version
       )
     end
 
@@ -186,13 +186,6 @@ 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

@@ -41,6 +41,11 @@ module HTTP
         end
       end
 
+      # Request bodies are equivalent when they have the same source.
+      def ==(other)
+        self.class == other.class && self.source == other.source # rubocop:disable Style/RedundantSelf
+      end
+
       private
 
       def validate_source_type!

data/lib/http/request/writer.rb

@@ -60,22 +60,32 @@ module HTTP
         @request_header.join(CRLF) + CRLF * 2
       end
 
+      # Writes HTTP request data into the socket.
       def send_request
-        # 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.
+        each_chunk { |chunk| write chunk }
+      rescue Errno::EPIPE
+        # server doesn't need any more data
+        nil
+      end
+
+      # Yields chunks of request data that should be sent to the socket.
+      #
+      # 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.
+      def each_chunk
         data = join_headers
 
         @body.each do |chunk|
           data << encode_chunk(chunk)
-          write(data)
+          yield data
           data.clear
         end
 
-        write(data) unless data.empty?
+        yield data unless data.empty?
 
-        write(CHUNKED_END) if chunked?
+        yield CHUNKED_END if chunked?
       end
 
       # Returns the chunk encoded for to the specified "Transfer-Encoding" header.
@@ -100,6 +110,10 @@ module HTTP
           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
       end
     end
   end

data/lib/http/response.rb

@@ -20,6 +20,9 @@ module HTTP
     # @return [Status]
     attr_reader :status
 
+    # @return [String]
+    attr_reader :version
+
     # @return [Body]
     attr_reader :body
 
@@ -46,14 +49,13 @@ module HTTP
       @headers       = HTTP::Headers.coerce(opts[:headers] || {})
       @proxy_headers = HTTP::Headers.coerce(opts[:proxy_headers] || {})
 
-      if opts.include?(:connection)
+      if opts.include?(:body)
+        @body = opts.fetch(:body)
+      else
         connection = opts.fetch(:connection)
         encoding   = opts[:encoding] || charset || Encoding::BINARY
-        stream     = body_stream_for(connection, opts)
 
-        @body = Response::Body.new(stream, :encoding => encoding)
-      else
-        @body = opts.fetch(:body)
+        @body = Response::Body.new(connection, :encoding => encoding)
       end
     end
 
@@ -160,15 +162,5 @@ module HTTP
     def inspect
       "#<#{self.class}/#{@version} #{code} #{reason} #{headers.to_h.inspect}>"
     end
-
-    private
-
-    def body_stream_for(connection, opts)
-      if opts[:auto_inflate]
-        opts[:auto_inflate].stream_for(connection, self)
-      else
-        connection
-      end
-    end
   end
 end

data/lib/http/timeout/global.rb

@@ -3,27 +3,25 @@
 require "timeout"
 require "io/wait"
 
-require "http/timeout/per_operation"
+require "http/timeout/null"
 
 module HTTP
   module Timeout
-    class Global < PerOperation
-      attr_reader :time_left, :total_timeout
-
+    class Global < Null
       def initialize(*args)
         super
-        reset_counter
+
+        @timeout = @time_left = options.fetch(:global_timeout)
       end
 
       # To future me: Don't remove this again, past you was smarter.
       def reset_counter
-        @time_left = connect_timeout + read_timeout + write_timeout
-        @total_timeout = time_left
+        @time_left = @timeout
       end
 
       def connect(socket_class, host, port, nodelay = false)
         reset_timer
-        ::Timeout.timeout(time_left, TimeoutError) do
+        ::Timeout.timeout(@time_left, TimeoutError) do
           @socket = socket_class.open(host, port)
           @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
@@ -37,11 +35,11 @@ module HTTP
         begin
           @socket.connect_nonblock
         rescue IO::WaitReadable
-          IO.select([@socket], nil, nil, time_left)
+          IO.select([@socket], nil, nil, @time_left)
           log_time
           retry
         rescue IO::WaitWritable
-          IO.select(nil, [@socket], nil, time_left)
+          IO.select(nil, [@socket], nil, @time_left)
           log_time
           retry
         end
@@ -105,13 +103,13 @@ module HTTP
 
       # Wait for a socket to become readable
       def wait_readable_or_timeout
-        @socket.to_io.wait_readable(time_left)
+        @socket.to_io.wait_readable(@time_left)
         log_time
       end
 
       # Wait for a socket to become writable
       def wait_writable_or_timeout
-        @socket.to_io.wait_writable(time_left)
+        @socket.to_io.wait_writable(@time_left)
         log_time
       end
 
@@ -123,8 +121,8 @@ module HTTP
 
       def log_time
         @time_left -= (Time.now - @started)
-        if time_left <= 0
-          raise TimeoutError, "Timed out after using the allocated #{total_timeout} seconds"
+        if @time_left <= 0
+          raise TimeoutError, "Timed out after using the allocated #{@timeout} seconds"
         end
 
         reset_timer

data/lib/http/timeout/per_operation.rb

@@ -11,8 +11,6 @@ module HTTP
       WRITE_TIMEOUT = 0.25
       READ_TIMEOUT = 0.25
 
-      attr_reader :read_timeout, :write_timeout, :connect_timeout
-
       def initialize(*args)
         super
 
@@ -22,7 +20,7 @@ module HTTP
       end
 
       def connect(socket_class, host, port, nodelay = false)
-        ::Timeout.timeout(connect_timeout, TimeoutError) do
+        ::Timeout.timeout(@connect_timeout, TimeoutError) do
           @socket = socket_class.open(host, port)
           @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
@@ -67,7 +65,7 @@ module HTTP
             return :eof   if result.nil?
             return result if result != :wait_readable
 
-            raise TimeoutError, "Read timed out after #{read_timeout} seconds" if timeout
+            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
@@ -78,7 +76,7 @@ module HTTP
             # 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)
+            timeout = true unless @socket.to_io.wait_readable(@read_timeout)
           end
         end
 
@@ -89,9 +87,9 @@ module HTTP
             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)
+            timeout = true unless @socket.to_io.wait_writable(@write_timeout)
           end
         end
 

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "3.3.0"
+  VERSION = "4.0.0"
 end

data/spec/lib/http/features/auto_inflate_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 RSpec.describe HTTP::Features::AutoInflate do
-  subject { HTTP::Features::AutoInflate.new }
+  subject(:feature) { HTTP::Features::AutoInflate.new }
   let(:connection) { double }
   let(:headers) { {} }
   let(:response) do
@@ -13,56 +13,52 @@ RSpec.describe HTTP::Features::AutoInflate do
     )
   end
 
-  describe "stream_for" do
+  describe "wrap_response" do
+    subject(:result) { feature.wrap_response(response) }
+
     context "when there is no Content-Encoding header" do
-      it "returns connection" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to eq(connection)
+      it "returns original request" do
+        expect(result).to be response
       end
     end
 
     context "for identity Content-Encoding header" do
-      let(:headers) { {:content_encoding => "not-supported"} }
+      let(:headers) { {:content_encoding => "identity"} }
 
-      it "returns connection" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to eq(connection)
+      it "returns original request" do
+        expect(result).to be response
       end
     end
 
     context "for unknown Content-Encoding header" do
       let(:headers) { {:content_encoding => "not-supported"} }
 
-      it "returns connection" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to eq(connection)
+      it "returns original request" do
+        expect(result).to be response
       end
     end
 
     context "for deflate Content-Encoding header" do
       let(:headers) { {:content_encoding => "deflate"} }
 
-      it "returns HTTP::Response::Inflater instance - connection wrapper" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to be_instance_of HTTP::Response::Inflater
+      it "returns a HTTP::Response wrapping the inflated response body" do
+        expect(result.body).to be_instance_of HTTP::Response::Body
       end
     end
 
     context "for gzip Content-Encoding header" do
       let(:headers) { {:content_encoding => "gzip"} }
 
-      it "returns HTTP::Response::Inflater instance - connection wrapper" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to be_instance_of HTTP::Response::Inflater
+      it "returns a HTTP::Response wrapping the inflated response body" do
+        expect(result.body).to be_instance_of HTTP::Response::Body
       end
     end
 
     context "for x-gzip Content-Encoding header" do
       let(:headers) { {:content_encoding => "x-gzip"} }
 
-      it "returns HTTP::Response::Inflater instance - connection wrapper" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to be_instance_of HTTP::Response::Inflater
+      it "returns a HTTP::Response wrapping the inflated response body" do
+        expect(result.body).to be_instance_of HTTP::Response::Body
       end
     end
   end