http 3.1.0 → 5.3.1

data/lib/http/feature.rb

@@ -2,8 +2,25 @@
 
 module HTTP
   class Feature
-    def initialize(opts = {}) # rubocop:disable Style/OptionHash
+    def initialize(opts = {})
       @opts = opts
     end
+
+    def wrap_request(request)
+      request
+    end
+
+    def wrap_response(response)
+      response
+    end
+
+    def on_error(request, error); end
   end
 end
+
+require "http/features/auto_inflate"
+require "http/features/auto_deflate"
+require "http/features/instrumentation"
+require "http/features/logging"
+require "http/features/normalize_uri"
+require "http/features/raise_error"

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,41 @@
 # 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),
+          :request       => response.request
+        }
+
+        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,69 @@
+# 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, :error_name
+
+      def initialize(instrumenter: NullInstrumenter.new, namespace: "http")
+        @instrumenter = instrumenter
+        @name = "request.#{namespace}"
+        @error_name = "error.#{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
+
+      def on_error(request, error)
+        instrumenter.instrument(error_name, :request => request, :error => error)
+      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,53 @@
+# 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
+      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)
+        @logger = logger
+      end
+
+      def wrap_request(request)
+        logger.info { "> #{request.verb.to_s.upcase} #{request.uri}" }
+        logger.debug { "#{stringify_headers(request.headers)}\n\n#{request.body.source}" }
+
+        request
+      end
+
+      def wrap_response(response)
+        logger.info { "< #{response.status}" }
+        logger.debug { "#{stringify_headers(response.headers)}\n\n#{response.body}" }
+
+        response
+      end
+
+      private
+
+      def stringify_headers(headers)
+        headers.map { |name, value| "#{name}: #{value}" }.join("\n")
+      end
+    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/features/raise_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module HTTP
+  module Features
+    class RaiseError < Feature
+      def initialize(ignore: [])
+        super()
+
+        @ignore = ignore
+      end
+
+      def wrap_response(response)
+        return response if response.code < 400
+        return response if @ignore.include?(response.code)
+
+        raise HTTP::StatusError, response
+      end
+
+      HTTP::Options.register_feature(:raise_error, 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/headers/normalizer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module HTTP
+  class Headers
+    class Normalizer
+      # Matches HTTP header names when in "Canonical-Http-Format"
+      CANONICAL_NAME_RE = /\A[A-Z][a-z]*(?:-[A-Z][a-z]*)*\z/
+
+      # Matches valid header field name according to RFC.
+      # @see http://tools.ietf.org/html/rfc7230#section-3.2
+      COMPLIANT_NAME_RE = /\A[A-Za-z0-9!#$%&'*+\-.^_`|~]+\z/
+
+      NAME_PARTS_SEPARATOR_RE = /[\-_]/
+
+      # @private
+      # Normalized header names cache
+      class Cache
+        MAX_SIZE = 200
+
+        def initialize
+          @store = {}
+        end
+
+        def get(key)
+          @store[key]
+        end
+        alias [] get
+
+        def set(key, value)
+          # Maintain cache size
+          @store.delete(@store.each_key.first) while MAX_SIZE <= @store.size
+
+          @store[key] = value
+        end
+        alias []= set
+      end
+
+      def initialize
+        @cache = Cache.new
+      end
+
+      # Transforms `name` to canonical HTTP header capitalization
+      def call(name)
+        name  = -name.to_s
+        value = (@cache[name] ||= -normalize_header(name))
+
+        value.dup
+      end
+
+      private
+
+      # Transforms `name` to canonical HTTP header capitalization
+      #
+      # @param [String] name
+      # @raise [HeaderError] if normalized name does not
+      #   match {COMPLIANT_NAME_RE}
+      # @return [String] canonical HTTP header name
+      def normalize_header(name)
+        return name if CANONICAL_NAME_RE.match?(name)
+
+        normalized = name.split(NAME_PARTS_SEPARATOR_RE).each(&:capitalize!).join("-")
+
+        return normalized if COMPLIANT_NAME_RE.match?(normalized)
+
+        raise HeaderError, "Invalid HTTP header field name: #{name.inspect}"
+      end
+    end
+  end
+end

data/lib/http/headers.rb

@@ -4,6 +4,7 @@ require "forwardable"
 
 require "http/errors"
 require "http/headers/mixin"
+require "http/headers/normalizer"
 require "http/headers/known"
 
 module HTTP
@@ -12,15 +13,38 @@ module HTTP
     extend Forwardable
     include Enumerable
 
-    # Matches HTTP header names when in "Canonical-Http-Format"
-    CANONICAL_NAME_RE = /^[A-Z][a-z]*(?:-[A-Z][a-z]*)*$/
+    class << self
+      # Coerces given `object` into Headers.
+      #
+      # @raise [Error] if object can't be coerced
+      # @param [#to_hash, #to_h, #to_a] object
+      # @return [Headers]
+      def coerce(object)
+        unless object.is_a? self
+          object = case
+                   when object.respond_to?(:to_hash) then object.to_hash
+                   when object.respond_to?(:to_h)    then object.to_h
+                   when object.respond_to?(:to_a)    then object.to_a
+                   else raise Error, "Can't coerce #{object.inspect} to Headers"
+                   end
+        end
+        headers = new
+        object.each { |k, v| headers.add k, v }
+        headers
+      end
+      alias [] coerce
 
-    # 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!#\$%&'*+\-.^_`|~]+$/
+      def normalizer
+        @normalizer ||= Headers::Normalizer.new
+      end
+    end
 
     # 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 +69,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 +101,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 +131,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 +139,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 +153,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 +161,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 +171,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 +184,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 +195,7 @@ module HTTP
     # @api private
     def initialize_copy(orig)
       super
-      @pile = to_a
+      @pile = @pile.map(&:dup)
     end
 
     # Merges `other` headers into `self`.
@@ -169,45 +214,23 @@ module HTTP
       dup.tap { |dupped| dupped.merge! other }
     end
 
-    class << self
-      # Coerces given `object` into Headers.
-      #
-      # @raise [Error] if object can't be coerced
-      # @param [#to_hash, #to_h, #to_a] object
-      # @return [Headers]
-      def coerce(object)
-        unless object.is_a? self
-          object = case
-                   when object.respond_to?(:to_hash) then object.to_hash
-                   when object.respond_to?(:to_h)    then object.to_h
-                   when object.respond_to?(:to_a)    then object.to_a
-                   else raise Error, "Can't coerce #{object.inspect} to Headers"
-                   end
-        end
-
-        headers = new
-        object.each { |k, v| headers.add k, v }
-        headers
-      end
-      alias [] coerce
-    end
-
     private
 
     # Transforms `name` to canonical HTTP header capitalization
-    #
-    # @param [String] name
-    # @raise [HeaderError] if normalized name does not
-    #   match {HEADER_NAME_RE}
-    # @return [String] canonical HTTP header name
     def normalize_header(name)
-      return name if name =~ CANONICAL_NAME_RE
-
-      normalized = name.split(/[\-_]/).each(&:capitalize!).join("-")
+      self.class.normalizer.call(name)
+    end
 
-      return normalized if normalized =~ COMPLIANT_NAME_RE
+    # 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 name: #{name.inspect}"
+      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