http 5.0.0.pre → 5.0.0.pre2

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

@@ -64,6 +64,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/parser.rb

@@ -49,14 +49,17 @@ module HTTP
       #
 
       def on_header_field(_response, field)
-        @field = field
+        append_header if @reading_header_value
+        @field << field
       end
 
       def on_header_value(_response, value)
-        @headers.add(@field, value) if @field
+        @reading_header_value = true
+        @field_value << value
       end
 
       def on_headers_complete(_reposse)
+        append_header if @reading_header_value
         @finished[:headers] = true
       end
 
@@ -89,15 +92,26 @@ module HTTP
       def reset
         @state.reset!
 
-        @finished = Hash.new(false)
-        @headers  = HTTP::Headers.new
-        @field    = nil
-        @chunk    = nil
+        @finished             = Hash.new(false)
+        @headers              = HTTP::Headers.new
+        @reading_header_value = false
+        @field                = +""
+        @field_value          = +""
+        @chunk                = nil
       end
 
       def finished?
         @finished[:message]
       end
+
+      private
+
+      def append_header
+        @headers.add(@field, @field_value)
+        @reading_header_value = false
+        @field_value          = +""
+        @field                = +""
+      end
     end
   end
 end

data/lib/http/response/status.rb

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

@@ -121,9 +121,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

data/lib/http/timeout/per_operation.rb

@@ -66,6 +66,7 @@ module HTTP
             return result if result != :wait_readable
 
             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

data/lib/http/uri.rb

@@ -26,6 +26,19 @@ module HTTP
     # @private
     HTTPS_SCHEME = "https"
 
+    # @private
+    NORMALIZER = lambda do |uri|
+      uri = HTTP::URI.parse uri
+
+      HTTP::URI.new(
+        :scheme    => uri.normalized_scheme,
+        :authority => uri.normalized_authority,
+        :path      => uri.normalized_path,
+        :query     => uri.query,
+        :fragment  => uri.normalized_fragment
+      )
+    end
+
     # Parse the given URI string, returning an HTTP::URI object
     #
     # @param [HTTP::URI, String, #to_str] uri to parse

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "5.0.0.pre"
+  VERSION = "5.0.0.pre2"
 end

data/spec/lib/http/client_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
 
 require "support/http_handling_shared"
 require "support/dummy_server"
@@ -10,7 +10,8 @@ RSpec.describe HTTP::Client do
 
   StubbedClient = Class.new(HTTP::Client) do
     def perform(request, options)
-      stubs.fetch(request.uri) { super(request, options) }
+      stubbed = stubs[request.uri]
+      stubbed ? stubbed.call(request) : super(request, options)
     end
 
     def stubs
@@ -27,20 +28,26 @@ RSpec.describe HTTP::Client do
   end
 
   def redirect_response(location, status = 302)
-    HTTP::Response.new(
-      :status  => status,
-      :version => "1.1",
-      :headers => {"Location" => location},
-      :body    => ""
-    )
+    lambda do |request|
+      HTTP::Response.new(
+        :status  => status,
+        :version => "1.1",
+        :headers => {"Location" => location},
+        :body    => "",
+        :request => request
+      )
+    end
   end
 
   def simple_response(body, status = 200)
-    HTTP::Response.new(
-      :status  => status,
-      :version => "1.1",
-      :body    => body
-    )
+    lambda do |request|
+      HTTP::Response.new(
+        :status  => status,
+        :version => "1.1",
+        :body    => body,
+        :request => request
+      )
+    end
   end
 
   describe "following redirects" do
@@ -234,7 +241,7 @@ RSpec.describe HTTP::Client do
 
     context "when :auto_deflate was specified" do
       let(:headers) { {"Content-Length" => "12"} }
-      let(:client)  { described_class.new :headers => headers, :features => {:auto_deflate => {}} }
+      let(:client)  { described_class.new :headers => headers, :features => {:auto_deflate => {}}, :body => "foo" }
 
       it "deletes Content-Length header" do
         expect(client).to receive(:perform) do |req, _|
@@ -251,6 +258,73 @@ RSpec.describe HTTP::Client do
 
         client.request(:get, "http://example.com/")
       end
+
+      context "and there is no body" do
+        let(:client) { described_class.new :headers => headers, :features => {:auto_deflate => {}} }
+
+        it "doesn't set Content-Encoding header" do
+          expect(client).to receive(:perform) do |req, _|
+            expect(req.headers).not_to include "Content-Encoding"
+          end
+
+          client.request(:get, "http://example.com/")
+        end
+      end
+    end
+
+    context "Feature" do
+      let(:feature_class) do
+        Class.new(HTTP::Feature) do
+          attr_reader :captured_request, :captured_response, :captured_error
+
+          def wrap_request(request)
+            @captured_request = request
+          end
+
+          def wrap_response(response)
+            @captured_response = response
+          end
+
+          def on_error(request, error)
+            @captured_request = request
+            @captured_error = error
+          end
+        end
+      end
+      it "is given a chance to wrap the Request" do
+        feature_instance = feature_class.new
+
+        response = client.use(:test_feature => feature_instance).
+                   request(:get, dummy.endpoint)
+
+        expect(response.code).to eq(200)
+        expect(feature_instance.captured_request.verb).to eq(:get)
+        expect(feature_instance.captured_request.uri.to_s).to eq(dummy.endpoint + "/")
+      end
+
+      it "is given a chance to wrap the Response" do
+        feature_instance = feature_class.new
+
+        response = client.use(:test_feature => feature_instance).
+                   request(:get, dummy.endpoint)
+
+        expect(feature_instance.captured_response).to eq(response)
+      end
+
+      it "is given a chance to handle an error" do
+        sleep_url = "#{dummy.endpoint}/sleep"
+        feature_instance = feature_class.new
+
+        expect do
+          client.use(:test_feature => feature_instance).
+            timeout(0.2).
+            request(:post, sleep_url)
+        end.to raise_error(HTTP::TimeoutError)
+
+        expect(feature_instance.captured_error).to be_a(HTTP::TimeoutError)
+        expect(feature_instance.captured_request.verb).to eq(:post)
+        expect(feature_instance.captured_request.uri.to_s).to eq(sleep_url)
+      end
     end
   end
 
@@ -304,6 +378,14 @@ RSpec.describe HTTP::Client do
       client.get(dummy.endpoint).to_s
     end
 
+    it "provides access to the Request from the Response" do
+      unique_value = "20190424"
+      response = client.headers("X-Value" => unique_value).get(dummy.endpoint)
+
+      expect(response.request).to be_a(HTTP::Request)
+      expect(response.request.headers["X-Value"]).to eq(unique_value)
+    end
+
     context "with HEAD request" do
       it "does not iterates through body" do
         expect_any_instance_of(HTTP::Connection).to_not receive(:readpartial)

data/spec/lib/http/connection_spec.rb

@@ -3,9 +3,9 @@
 RSpec.describe HTTP::Connection do
   let(:req) do
     HTTP::Request.new(
-      :verb     => :get,
-      :uri      => "http://example.com/",
-      :headers  => {}
+      :verb    => :get,
+      :uri     => "http://example.com/",
+      :headers => {}
     )
   end
   let(:socket) { double(:connect => nil) }
@@ -20,14 +20,17 @@ RSpec.describe HTTP::Connection do
         <<-RESPONSE.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
         | HTTP/1.1 200 OK
         | Content-Type: text
+        | foo_bar: 123
         |
         RESPONSE
       end
     end
 
-    it "reads data in parts" do
+    it "populates headers collection, preserving casing" do
       connection.read_headers!
-      expect(connection.headers).to eq("Content-Type" => "text")
+      expect(connection.headers).to eq("Content-Type" => "text", "foo_bar" => "123")
+      expect(connection.headers["Foo-Bar"]).to eq("123")
+      expect(connection.headers["foo_bar"]).to eq("123")
     end
   end
 

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

@@ -11,7 +11,8 @@ RSpec.describe HTTP::Features::AutoInflate do
       :version    => "1.1",
       :status     => 200,
       :headers    => headers,
-      :connection => connection
+      :connection => connection,
+      :request    => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
     )
   end
 
@@ -73,7 +74,8 @@ RSpec.describe HTTP::Features::AutoInflate do
           :status     => 200,
           :headers    => {:content_encoding => "gzip"},
           :connection => connection,
-          :uri        => "https://example.com"
+          :uri        => "https://example.com",
+          :request    => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
         )
       end
 

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

@@ -7,10 +7,10 @@ RSpec.describe HTTP::Features::Instrumentation do
   describe "logging the request" do
     let(:request) do
       HTTP::Request.new(
-        :verb => :post,
-        :uri => "https://example.com/",
+        :verb    => :post,
+        :uri     => "https://example.com/",
         :headers => {:accept => "application/json"},
-        :body => '{"hello": "world!"}'
+        :body    => '{"hello": "world!"}'
       )
     end
 
@@ -25,10 +25,11 @@ RSpec.describe HTTP::Features::Instrumentation do
     let(:response) do
       HTTP::Response.new(
         :version => "1.1",
-        :uri => "https://example.com",
-        :status => 200,
+        :uri     => "https://example.com",
+        :status  => 200,
         :headers => {:content_type => "application/json"},
-        :body => '{"success": true}'
+        :body    => '{"success": true}',
+        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
       )
     end