http 3.3.0 → 4.4.1

data/lib/http/connection.rb

@@ -7,7 +7,7 @@ require "http/response/parser"
 
 module HTTP
   # A connection to the HTTP server
-  class Connection # rubocop: disable Metrics/ClassLength
+  class Connection
     extend Forwardable
 
     # Allowed values for CONNECTION header
@@ -93,19 +93,15 @@ module HTTP
       chunk    = @parser.read(size)
       finish_response if finished
 
-      chunk.to_s
+      chunk || "".b
     end
 
     # Reads data from socket up until headers are loaded
     # @return [void]
     def read_headers!
-      loop do
-        if read_more(BUFFER_SIZE) == :eof
-          raise ConnectionError, "couldn't read response headers" unless @parser.headers?
-          break
-        elsif @parser.headers?
-          break
-        end
+      until @parser.headers?
+        result = read_more(BUFFER_SIZE)
+        raise ConnectionError, "couldn't read response headers" if result == :eof
       end
 
       set_keep_alive

data/lib/http/feature.rb

@@ -5,5 +5,19 @@ module HTTP
     def initialize(opts = {}) # rubocop:disable Style/OptionHash
       @opts = opts
     end
+
+    def wrap_request(request)
+      request
+    end
+
+    def wrap_response(response)
+      response
+    end
   end
 end
+
+require "http/features/auto_inflate"
+require "http/features/auto_deflate"
+require "http/features/logging"
+require "http/features/instrumentation"
+require "http/features/normalize_uri"

data/lib/http/features/auto_deflate.rb

@@ -3,12 +3,14 @@
 require "zlib"
 require "tempfile"
 
+require "http/request/body"
+
 module HTTP
   module Features
     class AutoDeflate < Feature
       attr_reader :method
 
-      def initialize(*)
+      def initialize(**)
         super
 
         @method = @opts.key?(:method) ? @opts[:method].to_s : "gzip"
@@ -16,20 +18,39 @@ module HTTP
         raise Error, "Only gzip and deflate methods are supported" unless %w[gzip deflate].include?(@method)
       end
 
+      def wrap_request(request)
+        return request unless method
+        return request if request.body.size.zero?
+
+        # We need to delete Content-Length header. It will be set automatically by HTTP::Request::Writer
+        request.headers.delete(Headers::CONTENT_LENGTH)
+        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),
+          :uri_normalizer => request.uri_normalizer
+        )
+      end
+
       def deflated_body(body)
         case method
         when "gzip"
           GzippedBody.new(body)
         when "deflate"
           DeflatedBody.new(body)
-        else
-          raise ArgumentError, "Unsupported deflate method: #{method}"
         end
       end
 
-      class CompressedBody
-        def initialize(body)
-          @body       = body
+      HTTP::Options.register_feature(:auto_deflate, self)
+
+      class CompressedBody < HTTP::Request::Body
+        def initialize(uncompressed_body)
+          @body       = uncompressed_body
           @compressed = nil
         end
 

data/lib/http/features/auto_inflate.rb

@@ -1,15 +1,42 @@
 # frozen_string_literal: true
 
+require "set"
+
 module HTTP
   module Features
     class AutoInflate < Feature
-      def stream_for(connection, response)
-        if %w[deflate gzip x-gzip].include?(response.headers[:content_encoding])
-          Response::Inflater.new(connection)
-        else
-          connection
-        end
+      SUPPORTED_ENCODING = Set.new(%w[deflate gzip x-gzip]).freeze
+      private_constant :SUPPORTED_ENCODING
+
+      def wrap_response(response)
+        return response unless supported_encoding?(response)
+
+        options = {
+          :status => response.status,
+          :version => response.version,
+          :headers => response.headers,
+          :proxy_headers => response.proxy_headers,
+          :connection => response.connection,
+          :body => stream_for(response.connection)
+        }
+
+        options[:uri] = response.uri if response.uri
+
+        Response.new(options)
       end
+
+      def stream_for(connection)
+        Response::Body.new(Response::Inflater.new(connection))
+      end
+
+      private
+
+      def supported_encoding?(response)
+        content_encoding = response.headers.get(Headers::CONTENT_ENCODING).first
+        content_encoding && SUPPORTED_ENCODING.include?(content_encoding)
+      end
+
+      HTTP::Options.register_feature(:auto_inflate, self)
     end
   end
 end

data/lib/http/features/instrumentation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Features
+    # Instrument requests and responses. Expects an
+    # ActiveSupport::Notifications-compatible instrumenter. Defaults to use a
+    # namespace of 'http' which may be overridden with a `:namespace` param.
+    # Emits a single event like `"request.{namespace}"`, eg `"request.http"`.
+    # Be sure to specify the instrumenter when enabling the feature:
+    #
+    #    HTTP
+    #      .use(instrumentation: {instrumenter: ActiveSupport::Notifications.instrumenter})
+    #      .get("https://example.com/")
+    #
+    # Emits two events on every request:
+    #
+    #  * `start_request.http` before the request is made, so you can log the reqest being started
+    #  * `request.http` after the response is recieved, and contains `start`
+    #    and `finish` so the duration of the request can be calculated.
+    #
+    class Instrumentation < Feature
+      attr_reader :instrumenter, :name
+
+      def initialize(instrumenter: NullInstrumenter.new, namespace: "http")
+        @instrumenter = instrumenter
+        @name = "request.#{namespace}"
+      end
+
+      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.start(name, :request => request)
+        request
+      end
+
+      def wrap_response(response)
+        instrumenter.finish(name, :response => response)
+        response
+      end
+
+      HTTP::Options.register_feature(:instrumentation, self)
+
+      class NullInstrumenter
+        def instrument(name, payload = {})
+          start(name, payload)
+          begin
+            yield payload if block_given?
+          ensure
+            finish name, payload
+          end
+        end
+
+        def start(_name, _payload)
+          true
+        end
+
+        def finish(_name, _payload)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/http/features/logging.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Features
+    # Log requests and responses. Request verb and uri, and Response status are
+    # logged at `info`, and the headers and bodies of both are logged at
+    # `debug`. Be sure to specify the logger when enabling the feature:
+    #
+    #    HTTP.use(logging: {logger: Logger.new(STDOUT)}).get("https://example.com/")
+    #
+    class Logging < Feature
+      attr_reader :logger
+
+      def initialize(logger: NullLogger.new)
+        @logger = logger
+      end
+
+      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
+
+          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
+
+          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
+
+          define_method(:"#{level}?") do
+            true
+          end
+        end
+      end
+
+      HTTP::Options.register_feature(:logging, self)
+    end
+  end
+end

data/lib/http/features/normalize_uri.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "http/uri"
+
+module HTTP
+  module Features
+    class NormalizeUri < Feature
+      attr_reader :normalizer
+
+      def initialize(normalizer: HTTP::URI::NORMALIZER)
+        @normalizer = normalizer
+      end
+
+      HTTP::Options.register_feature(:normalize_uri, self)
+    end
+  end
+end

data/lib/http/headers/known.rb

@@ -5,6 +5,9 @@ module HTTP
     # Content-Types that are acceptable for the response.
     ACCEPT = "Accept"
 
+    # Content-codings that are acceptable in the response.
+    ACCEPT_ENCODING = "Accept-Encoding"
+
     # The age the object has been in a proxy cache in seconds.
     AGE = "Age"
 

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)
@@ -112,19 +114,21 @@ module HTTP
                     unless (feature = self.class.available_features[name])
                       argument_error! "Unsupported feature: #{name}"
                     end
-                    feature.new(opts_or_feature)
+                    feature.new(**opts_or_feature)
                   end
       end
     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/redirector.rb

@@ -58,7 +58,8 @@ module HTTP
 
         @response.flush
 
-        @request  = redirect_to @response.headers[Headers::LOCATION]
+        # XXX(ixti): using `Array#inject` to return `nil` if no Location header.
+        @request  = redirect_to(@response.headers.get(Headers::LOCATION).inject(:+))
         @response = yield @request
       end