faraday 1.9.2 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4e484ac8258dd87916d0f5a1330846e8d786531250ccca90267415cca980d2f
-  data.tar.gz: 1ee679b83f3eaffd4b4c10f91e21a71e4b6b18f9b15bac8d9d937b52c1955770
+  metadata.gz: fc4d9e8162e07b207c4479907d77a4a4e0319b8f5d18bb1ce772eee108c0ed2a
+  data.tar.gz: c0753fcc74b610d2a4e0c5859917a5c98a0f177a7c83ba4c056e164dc0b37881
 SHA512:
-  metadata.gz: 4731a060a0a070fe5911447b415c43463cc96efe59e714c2e3e32110826af5ea9e451ab24d95c027c2fa0d0259c6d523f48eaa72eaa5f4c9aa3e9329f29862fb
-  data.tar.gz: 1df9244344683f56b583dd2bc0e8225ef36dc727ef8b3247a7b48ded40eae03da828424b7a0cb680fed70d18904c2b246cc7e779114ea716240308590ae36468
+  metadata.gz: d44910fd02c440547aa02843300dc0328b06697fe51d12406a8fc3216ee1cddef953f826bf807cedc71c14fcdb1aa28bd1e434693d45c8ffb8491706da81c6dc
+  data.tar.gz: 9b65773cc2275e0fdaddea26886b2e42befe982979d31ba24b816e679deeb496133ba6ca09d4cf5ba9695916cf20031982fad6df27bd056c052010b5e3d6cea1

data/lib/faraday/connection.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'faraday/deprecate'
+
 module Faraday
   # Connection objects manage the default properties and the middleware
   # stack for fulfilling an HTTP request.
@@ -297,14 +299,12 @@ module Faraday
     #
     # @return [void]
     def basic_auth(login, pass)
-      warn <<~TEXT
-        WARNING: `Faraday::Connection#basic_auth` is deprecated; it will be removed in version 2.0.
-        While initializing your connection, use `#request(:basic_auth, ...)` instead.
-        See https://lostisland.github.io/faraday/middleware/authentication for more usage info.
-      TEXT
       set_authorization_header(:basic_auth, login, pass)
     end
 
+    extend Faraday::Deprecate
+    deprecate :basic_auth, '#request(:basic_auth, ...)', '2.0'
+
     # Sets up the Authorization header with the given token.
     #
     # @param token [String]

data/lib/faraday/deprecate.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Faraday
+  # @param new_klass [Class] new Klass to use
+  #
+  # @return [Class] A modified version of new_klass that warns on
+  #   usage about deprecation.
+  # @see Faraday::Deprecate
+  module DeprecatedClass
+    def self.proxy_class(origclass, ver = '1.0')
+      proxy = Class.new(origclass) do
+        const_set('ORIG_CLASS', origclass)
+
+        class << self
+          extend Faraday::Deprecate
+
+          def ===(other)
+            (superclass == const_get('ORIG_CLASS') && other.is_a?(superclass)) || super
+          end
+        end
+      end
+      proxy.singleton_class.send(:deprecate, :new, "#{origclass}.new", ver)
+      proxy.singleton_class.send(:deprecate, :inherited, origclass.name, ver)
+      proxy
+    end
+  end
+
+  # Deprecation using semver instead of date, based on Gem::Deprecate
+  # Provides a single method +deprecate+ to be used to declare when
+  # something is going away.
+  #
+  #     class Legacy
+  #       def self.klass_method
+  #         # ...
+  #       end
+  #
+  #       def instance_method
+  #         # ...
+  #       end
+  #
+  #       extend Faraday::Deprecate
+  #       deprecate :instance_method, "X.z", '1.0'
+  #
+  #       class << self
+  #         extend Faraday::Deprecate
+  #         deprecate :klass_method, :none, '1.0'
+  #       end
+  #     end
+  module Deprecate
+    def self.skip # :nodoc:
+      @skip ||= begin
+        case ENV['FARADAY_DEPRECATE'].to_s.downcase
+        when '1', 'warn' then :warn
+        else :skip
+        end
+      end
+      @skip == :skip
+    end
+
+    def self.skip=(value) # :nodoc:
+      @skip = value ? :skip : :warn
+    end
+
+    # Temporarily turn off warnings. Intended for tests only.
+    def skip_during
+      original = Faraday::Deprecate.skip
+      Faraday::Deprecate.skip = true
+      yield
+    ensure
+      Faraday::Deprecate.skip = original
+    end
+
+    # Simple deprecation method that deprecates +name+ by wrapping it up
+    # in a dummy method. It warns on each call to the dummy method
+    # telling the user of +repl+ (unless +repl+ is :none) and the
+    # semver that it is planned to go away.
+    # @param name [Symbol] the method symbol to deprecate
+    # @param repl [#to_s, :none] the replacement to use, when `:none` it will
+    #   alert the user that no replacemtent is present.
+    # @param ver [String] the semver the method will be removed.
+    def deprecate(name, repl, ver)
+      class_eval do
+        gem_ver = Gem::Version.new(ver)
+        old = "_deprecated_#{name}"
+        alias_method old, name
+        define_method name do |*args, &block|
+          mod = is_a? Module
+          target = mod ? "#{self}." : "#{self.class}#"
+          target_message = if name == :inherited
+                             "Inheriting #{self}"
+                           else
+                             "#{target}#{name}"
+                           end
+
+          msg = [
+            "NOTE: #{target_message} is deprecated",
+            repl == :none ? ' with no replacement' : "; use #{repl} instead. ",
+            "It will be removed in or after version #{gem_ver}",
+            "\n#{target}#{name} called from #{Gem.location_of_caller.join(':')}"
+          ]
+          warn "#{msg.join}." unless Faraday::Deprecate.skip
+          send old, *args, &block
+        end
+      end
+    end
+
+    module_function :deprecate, :skip_during
+  end
+end

data/lib/faraday/request/json.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Request
+    # Request middleware that encodes the body as JSON.
+    #
+    # Processes only requests with matching Content-type or those without a type.
+    # If a request doesn't have a type but has a body, it sets the Content-type
+    # to JSON MIME-type.
+    #
+    # Doesn't try to encode bodies that already are in string form.
+    class Json < Middleware
+      MIME_TYPE = 'application/json'
+      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+
+      def on_request(env)
+        match_content_type(env) do |data|
+          env[:body] = encode(data)
+        end
+      end
+
+      private
+
+      def encode(data)
+        ::JSON.generate(data)
+      end
+
+      def match_content_type(env)
+        return unless process_request?(env)
+
+        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+        yield env[:body] unless env[:body].respond_to?(:to_str)
+      end
+
+      def process_request?(env)
+        type = request_type(env)
+        body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
+      end
+
+      def body?(env)
+        (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+      end
+
+      def request_type(env)
+        type = env[:request_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Request.register_middleware(json: Faraday::Request::Json)

data/lib/faraday/request.rb

@@ -44,7 +44,8 @@ module Faraday
                           :TokenAuthentication,
                           'token_authentication'
                         ],
-                        instrumentation: [:Instrumentation, 'instrumentation']
+                        instrumentation: [:Instrumentation, 'instrumentation'],
+                        json: [:Json, 'json']
 
     # @param request_method [String]
     # @yield [request] for block customization, if block given
@@ -138,11 +139,11 @@ module Faraday
     # @param serialised [Hash] the serialised object.
     def marshal_load(serialised)
       self.http_method = serialised[:http_method]
-      self.body        = serialised[:body]
-      self.headers     = serialised[:headers]
-      self.path        = serialised[:path]
-      self.params      = serialised[:params]
-      self.options     = serialised[:options]
+      self.body = serialised[:body]
+      self.headers = serialised[:headers]
+      self.path = serialised[:path]
+      self.params = serialised[:params]
+      self.options = serialised[:options]
     end
 
     # @return [Env] the Env for this Request

data/lib/faraday/response/json.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Response
+    # Parse response bodies as JSON.
+    class Json < Middleware
+      def initialize(app = nil, options = {})
+        super(app)
+        @parser_options = options[:parser_options]
+        @content_types = Array(options[:content_type] || /\bjson$/)
+        @preserve_raw = options[:preserve_raw]
+      end
+
+      def on_complete(env)
+        process_response(env) if parse_response?(env)
+      end
+
+      private
+
+      def process_response(env)
+        env[:raw_body] = env[:body] if @preserve_raw
+        env[:body] = parse(env[:body])
+      rescue StandardError, SyntaxError => e
+        raise Faraday::ParsingError.new(e, env[:response])
+      end
+
+      def parse(body)
+        ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+      end
+
+      def parse_response?(env)
+        process_response_type?(env) &&
+          env[:body].respond_to?(:to_str)
+      end
+
+      def process_response_type?(env)
+        type = response_type(env)
+        @content_types.empty? || @content_types.any? do |pattern|
+          pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
+        end
+      end
+
+      def response_type(env)
+        type = env[:response_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Faraday::Response::Json)

data/lib/faraday/response/logger.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'forwardable'
+require 'logger'
 require 'faraday/logging/formatter'
 
 module Faraday
@@ -11,10 +12,7 @@ module Faraday
     class Logger < Middleware
       def initialize(app, logger = nil, options = {})
         super(app)
-        logger ||= begin
-          require 'logger'
-          ::Logger.new($stdout)
-        end
+        logger ||= ::Logger.new($stdout)
         formatter_class = options.delete(:formatter) || Logging::Formatter
         @formatter = formatter_class.new(logger: logger, options: options)
         yield @formatter if block_given?

data/lib/faraday/response.rb

@@ -22,7 +22,8 @@ module Faraday
 
     register_middleware File.expand_path('response', __dir__),
                         raise_error: [:RaiseError, 'raise_error'],
-                        logger: [:Logger, 'logger']
+                        logger: [:Logger, 'logger'],
+                        json: [:Json, 'json']
 
     def initialize(env = nil)
       @env = Env.from(env) if env
@@ -42,6 +43,7 @@ module Faraday
     def headers
       finished? ? env.response_headers : {}
     end
+
     def_delegator :headers, :[]
 
     def body

data/lib/faraday/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Faraday
-  VERSION = '1.9.2'
+  VERSION = '1.10.1'
 end

data/lib/faraday.rb

@@ -57,6 +57,8 @@ require 'faraday/rack'
 #   conn.get '/'
 #
 module Faraday
+  CONTENT_TYPE = 'Content-Type'
+
   class << self
     # The root path that Faraday is being loaded from.
     #

data/spec/faraday/deprecate_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::DeprecatedClass do
+  class SampleClass < StandardError
+    attr_accessor :foo
+
+    def initialize(foo = nil)
+      @foo = foo || :foo
+    end
+  end
+
+  SampleDeprecatedClass = Faraday::DeprecatedClass.proxy_class(SampleClass)
+
+  it 'does not raise error for deprecated classes but prints an error message' do
+    error_message, foobar = with_warn_squelching { SampleDeprecatedClass.new(:foo_bar) }
+    expect(foobar).to be_a(SampleClass)
+    expect(foobar.foo).to eq(:foo_bar)
+    expect(error_message).to match(
+      Regexp.new(
+        'NOTE: SampleDeprecatedClass.new is deprecated; '\
+        'use SampleClass.new instead. It will be removed in or after version 1.0'
+      )
+    )
+  end
+
+  it 'does not raise an error for inherited error-namespaced classes but prints an error message' do
+    error_message, = with_warn_squelching { Class.new(SampleDeprecatedClass) }
+
+    expect(error_message).to match(
+      Regexp.new(
+        'NOTE: Inheriting SampleDeprecatedClass is deprecated; '\
+        'use SampleClass instead. It will be removed in or after version 1.0'
+      )
+    )
+  end
+
+  it 'allows backward-compatible class to be subclassed' do
+    expect do
+      with_warn_squelching { Class.new(SampleDeprecatedClass) }
+    end.not_to raise_error
+  end
+
+  it 'allows rescuing of a current error with a deprecated error' do
+    expect { raise SampleClass, nil }.to raise_error(SampleDeprecatedClass)
+  end
+
+  it 'allows rescuing of a current error with a current error' do
+    expect { raise SampleClass, nil }.to raise_error(SampleClass)
+  end
+
+  it 'allows rescuing of a deprecated error with a deprecated error' do
+    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleDeprecatedClass)
+  end
+
+  it 'allows rescuing of a deprecated error with a current error' do
+    expect { raise SampleDeprecatedClass, nil }.to raise_error(SampleClass)
+  end
+
+  describe 'match behavior' do
+    class SampleDeprecatedClassA < SampleDeprecatedClass; end
+    class SampleDeprecatedClassB < SampleDeprecatedClass; end
+
+    class SampleDeprecatedClassAX < SampleDeprecatedClassA; end
+
+    class SampleClassA < SampleClass; end
+
+    describe 'undeprecated class' do
+      it 'is === to instance of deprecated class' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleClass)).to be true
+      end
+
+      it 'is === to instance of subclass of deprecated class' do
+        expect(SampleDeprecatedClassA.new.is_a?(SampleClass)).to be true
+      end
+
+      it 'is === to instance of subclass of subclass of deprecated class' do
+        expect(SampleDeprecatedClassAX.new.is_a?(SampleClass)).to be true
+      end
+    end
+
+    describe 'subclass of undeprecated class' do
+      it 'is not === to instance of undeprecated class' do
+        expect(SampleClass.new.is_a?(SampleClassA)).to be false
+      end
+
+      it 'is not === to instance of deprecated class' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleClassA)).to be false
+      end
+    end
+
+    describe 'deprecated class' do
+      it 'is === to instance of undeprecated class' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleClass)).to be true
+      end
+
+      it 'is === to instance of subclass of undeprecated class' do
+        expect(SampleClassA.superclass == SampleDeprecatedClass.superclass).to be true
+      end
+
+      it 'is === to instance of subclass of deprecated class' do
+        expect(SampleDeprecatedClassA.new.is_a?(SampleDeprecatedClass)).to be true
+      end
+
+      it 'is === to instance of subclass of subclass of deprecated class' do
+        expect(SampleDeprecatedClassAX.new.is_a?(SampleDeprecatedClass)).to be true
+      end
+    end
+
+    describe 'subclass of deprecated class' do
+      it 'is not === to instance of subclass of undeprecated class' do
+        expect(SampleClass.new.is_a?(SampleDeprecatedClassA)).to be false
+      end
+
+      it 'is not === to instance of another subclass of deprecated class' do
+        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClassA)).to be false
+      end
+
+      it 'is === to instance of its subclass' do
+        expect(SampleDeprecatedClassAX.new.is_a?(SampleDeprecatedClassA)).to be true
+      end
+
+      it 'is === to instance of deprecated class' do
+        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClass)).to be true
+      end
+    end
+
+    describe 'subclass of subclass of deprecated class' do
+      it 'is not === to instance of subclass of another subclass of deprecated class' do
+        expect(SampleDeprecatedClassB.new.is_a?(SampleDeprecatedClassAX)).to be false
+      end
+
+      it 'is not === to instance of its superclass' do
+        expect(SampleDeprecatedClass.new.is_a?(SampleDeprecatedClassA)).to be false
+      end
+    end
+  end
+
+  def with_warn_squelching
+    stderr_catcher = StringIO.new
+    original_stderr = $stderr
+    $stderr = stderr_catcher
+    result = yield if block_given?
+    [stderr_catcher.tap(&:rewind).string, result]
+  ensure
+    $stderr = original_stderr
+  end
+end

data/spec/faraday/request/instrumentation_spec.rb

@@ -30,11 +30,13 @@ RSpec.describe Faraday::Request::Instrumentation do
 
   it { expect(options.name).to eq('request.faraday') }
   it 'defaults to ActiveSupport::Notifications' do
-    res = options.instrumenter
-  rescue NameError => e
-    expect(e.to_s).to match('ActiveSupport')
-  else
-    expect(res).to eq(ActiveSupport::Notifications)
+    begin
+      res = options.instrumenter
+    rescue NameError => e
+      expect(e.to_s).to match('ActiveSupport')
+    else
+      expect(res).to eq(ActiveSupport::Notifications)
+    end
   end
 
   it 'instruments with default name' do

data/spec/faraday/request/json_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Request::Json do
+  let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
+
+  def process(body, content_type = nil)
+    env = { body: body, request_headers: Faraday::Utils::Headers.new }
+    env[:request_headers]['content-type'] = content_type if content_type
+    middleware.call(Faraday::Env.from(env)).env
+  end
+
+  def result_body
+    result[:body]
+  end
+
+  def result_type
+    result[:request_headers]['content-type']
+  end
+
+  context 'no body' do
+    let(:result) { process(nil) }
+
+    it "doesn't change body" do
+      expect(result_body).to be_nil
+    end
+
+    it "doesn't add content type" do
+      expect(result_type).to be_nil
+    end
+  end
+
+  context 'empty body' do
+    let(:result) { process('') }
+
+    it "doesn't change body" do
+      expect(result_body).to be_empty
+    end
+
+    it "doesn't add content type" do
+      expect(result_type).to be_nil
+    end
+  end
+
+  context 'string body' do
+    let(:result) { process('{"a":1}') }
+
+    it "doesn't change body" do
+      expect(result_body).to eq('{"a":1}')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
+  context 'object body' do
+    let(:result) { process(a: 1) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{"a":1}')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
+  context 'empty object body' do
+    let(:result) { process({}) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{}')
+    end
+  end
+
+  context 'object body with json type' do
+    let(:result) { process({ a: 1 }, 'application/json; charset=utf-8') }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{"a":1}')
+    end
+
+    it "doesn't change content type" do
+      expect(result_type).to eq('application/json; charset=utf-8')
+    end
+  end
+
+  context 'object body with vendor json type' do
+    let(:result) { process({ a: 1 }, 'application/vnd.myapp.v1+json; charset=utf-8') }
+
+    it 'encodes body' do
+      expect(result_body).to eq('{"a":1}')
+    end
+
+    it "doesn't change content type" do
+      expect(result_type).to eq('application/vnd.myapp.v1+json; charset=utf-8')
+    end
+  end
+
+  context 'object body with incompatible type' do
+    let(:result) { process({ a: 1 }, 'application/xml; charset=utf-8') }
+
+    it "doesn't change body" do
+      expect(result_body).to eq(a: 1)
+    end
+
+    it "doesn't change content type" do
+      expect(result_type).to eq('application/xml; charset=utf-8')
+    end
+  end
+end

data/spec/faraday/response/json_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Faraday::Response::Json, type: :response do
+  let(:options) { {} }
+  let(:headers) { {} }
+  let(:middleware) do
+    described_class.new(lambda { |env|
+      Faraday::Response.new(env)
+    }, **options)
+  end
+
+  def process(body, content_type = 'application/json', options = {})
+    env = {
+      body: body, request: options,
+      request_headers: Faraday::Utils::Headers.new,
+      response_headers: Faraday::Utils::Headers.new(headers)
+    }
+    env[:response_headers]['content-type'] = content_type if content_type
+    yield(env) if block_given?
+    middleware.call(Faraday::Env.from(env))
+  end
+
+  context 'no type matching' do
+    it "doesn't change nil body" do
+      expect(process(nil).body).to be_nil
+    end
+
+    it 'nullifies empty body' do
+      expect(process('').body).to be_nil
+    end
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to be_nil
+    end
+  end
+
+  context 'with preserving raw' do
+    let(:options) { { preserve_raw: true } }
+
+    it 'parses json body' do
+      response = process('{"a":1}')
+      expect(response.body).to eq('a' => 1)
+      expect(response.env[:raw_body]).to eq('{"a":1}')
+    end
+  end
+
+  context 'with default regexp type matching' do
+    it 'parses json body of correct type' do
+      response = process('{"a":1}', 'application/x-json')
+      expect(response.body).to eq('a' => 1)
+    end
+
+    it 'ignores json body of incorrect type' do
+      response = process('{"a":1}', 'text/json-xml')
+      expect(response.body).to eq('{"a":1}')
+    end
+  end
+
+  context 'with array type matching' do
+    let(:options) { { content_type: %w[a/b c/d] } }
+
+    it 'parses json body of correct type' do
+      expect(process('{"a":1}', 'a/b').body).to be_a(Hash)
+      expect(process('{"a":1}', 'c/d').body).to be_a(Hash)
+    end
+
+    it 'ignores json body of incorrect type' do
+      expect(process('{"a":1}', 'a/d').body).not_to be_a(Hash)
+    end
+  end
+
+  it 'chokes on invalid json' do
+    expect { process('{!') }.to raise_error(Faraday::ParsingError)
+  end
+
+  it 'includes the response on the ParsingError instance' do
+    begin
+      process('{') { |env| env[:response] = Faraday::Response.new }
+      raise 'Parsing should have failed.'
+    rescue Faraday::ParsingError => e
+      expect(e.response).to be_a(Faraday::Response)
+    end
+  end
+
+  context 'HEAD responses' do
+    it "nullifies the body if it's only one space" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+
+    it "nullifies the body if it's two spaces" do
+      response = process(' ')
+      expect(response.body).to be_nil
+    end
+  end
+
+  context 'JSON options' do
+    let(:body) { '{"a": 1}' }
+    let(:result) { { a: 1 } }
+    let(:options) do
+      {
+        parser_options: {
+          symbolize_names: true
+        }
+      }
+    end
+
+    it 'passes relevant options to JSON parse' do
+      expect(::JSON).to receive(:parse)
+        .with(body, options[:parser_options])
+        .and_return(result)
+
+      response = process(body)
+      expect(response.body).to eq(result)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -38,6 +38,8 @@ require 'pry'
 
 Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
 
+Faraday::Deprecate.skip = false
+
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest

data/spec/support/webmock_rack_app.rb

@@ -41,7 +41,8 @@ class WebmockRackApp
 
   def req_headers(env)
     http_headers = env.select { |k, _| k.start_with?('HTTP_') }
-                      .transform_keys { |k| k[5..] }
+                      .map { |k, v| [k[5..-1], v] }
+                      .to_h
 
     special_headers = Faraday::Adapter::Rack::SPECIAL_HEADERS
     http_headers.merge(env.select { |k, _| special_headers.include?(k) })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.10.1
 platform: ruby
 authors:
 - "@technoweenie"
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-06 00:00:00.000000000 Z
+date: 2022-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday-em_http
@@ -186,6 +186,7 @@ files:
 - lib/faraday/autoload.rb
 - lib/faraday/connection.rb
 - lib/faraday/dependency_loader.rb
+- lib/faraday/deprecate.rb
 - lib/faraday/encoders/flat_params_encoder.rb
 - lib/faraday/encoders/nested_params_encoder.rb
 - lib/faraday/error.rb
@@ -205,9 +206,11 @@ files:
 - lib/faraday/request/authorization.rb
 - lib/faraday/request/basic_authentication.rb
 - lib/faraday/request/instrumentation.rb
+- lib/faraday/request/json.rb
 - lib/faraday/request/token_authentication.rb
 - lib/faraday/request/url_encoded.rb
 - lib/faraday/response.rb
+- lib/faraday/response/json.rb
 - lib/faraday/response/logger.rb
 - lib/faraday/response/raise_error.rb
 - lib/faraday/utils.rb
@@ -228,6 +231,7 @@ files:
 - spec/faraday/adapter_spec.rb
 - spec/faraday/composite_read_io_spec.rb
 - spec/faraday/connection_spec.rb
+- spec/faraday/deprecate_spec.rb
 - spec/faraday/error_spec.rb
 - spec/faraday/middleware_spec.rb
 - spec/faraday/options/env_spec.rb
@@ -239,8 +243,10 @@ files:
 - spec/faraday/rack_builder_spec.rb
 - spec/faraday/request/authorization_spec.rb
 - spec/faraday/request/instrumentation_spec.rb
+- spec/faraday/request/json_spec.rb
 - spec/faraday/request/url_encoded_spec.rb
 - spec/faraday/request_spec.rb
+- spec/faraday/response/json_spec.rb
 - spec/faraday/response/logger_spec.rb
 - spec/faraday/response/middleware_spec.rb
 - spec/faraday/response/raise_error_spec.rb
@@ -262,7 +268,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v1.9.2
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v1.10.1
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
 post_install_message: 
@@ -274,7 +280,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="