faraday 2.7.4 → 2.9.0

data/lib/faraday/options.rb

@@ -30,7 +30,7 @@ module Faraday
           new_value = value
         end
 
-        send("#{key}=", new_value) unless new_value.nil?
+        send(:"#{key}=", new_value) unless new_value.nil?
       end
       self
     end
@@ -38,7 +38,7 @@ module Faraday
     # Public
     def delete(key)
       value = send(key)
-      send("#{key}=", nil)
+      send(:"#{key}=", nil)
       value
     end
 
@@ -57,7 +57,7 @@ module Faraday
                     else
                       other_value
                     end
-        send("#{key}=", new_value) unless new_value.nil?
+        send(:"#{key}=", new_value) unless new_value.nil?
       end
       self
     end
@@ -174,6 +174,7 @@ module Faraday
 
       memoized_attributes[key.to_sym] = block
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        remove_method(key) if method_defined?(key, false)
         def #{key}() self[:#{key}]; end
       RUBY
     end

data/lib/faraday/rack_builder.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'ruby2_keywords'
 require 'faraday/adapter_registry'
 
 module Faraday

data/lib/faraday/request/instrumentation.rb

@@ -5,12 +5,14 @@ module Faraday
     # Middleware for instrumenting Requests.
     class Instrumentation < Faraday::Middleware
       # Options class used in Request::Instrumentation class.
-      class Options < Faraday::Options.new(:name, :instrumenter)
+      Options = Faraday::Options.new(:name, :instrumenter) do
+        remove_method :name
         # @return [String]
         def name
           self[:name] ||= 'request.faraday'
         end
 
+        remove_method :instrumenter
         # @return [Class]
         def instrumenter
           self[:instrumenter] ||= ActiveSupport::Notifications

data/lib/faraday/request/json.rb

@@ -13,7 +13,7 @@ module Faraday
     # 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
+      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}
 
       def on_request(env)
         match_content_type(env) do |data|
@@ -24,7 +24,13 @@ module Faraday
       private
 
       def encode(data)
-        ::JSON.generate(data)
+        if options[:encoder].is_a?(Array) && options[:encoder].size >= 2
+          options[:encoder][0].public_send(options[:encoder][1], data)
+        elsif options[:encoder].respond_to?(:dump)
+          options[:encoder].dump(data)
+        else
+          ::JSON.generate(data)
+        end
       end
 
       def match_content_type(env)
@@ -40,7 +46,16 @@ module Faraday
       end
 
       def body?(env)
-        (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+        body = env[:body]
+        case body
+        when true, false
+          true
+        when nil
+          # NOTE: nil can be converted to `"null"`, but this middleware doesn't process `nil` for the compatibility.
+          false
+        else
+          !(body.respond_to?(:to_str) && body.empty?)
+        end
       end
 
       def request_type(env)

data/lib/faraday/request.rb

@@ -24,13 +24,14 @@ module Faraday
   #   @return [String] body
   # @!attribute options
   #   @return [RequestOptions] options
-  #
-  # rubocop:disable Style/StructInheritance
-  class Request < Struct.new(:http_method, :path, :params, :headers, :body, :options)
-    # rubocop:enable Style/StructInheritance
-
+  Request = Struct.new(:http_method, :path, :params, :headers, :body, :options) do
     extend MiddlewareRegistry
 
+    alias_method :member_get, :[]
+    private :member_get
+    alias_method :member_set, :[]=
+    private :member_set
+
     # @param request_method [String]
     # @yield [request] for block customization, if block given
     # @yieldparam request [Request]
@@ -41,6 +42,7 @@ module Faraday
       end
     end
 
+    remove_method :params=
     # Replace params, preserving the existing hash type.
     #
     # @param hash [Hash] new params
@@ -48,10 +50,11 @@ module Faraday
       if params
         params.replace hash
       else
-        super
+        member_set(:params, hash)
       end
     end
 
+    remove_method :headers=
     # Replace request headers, preserving the existing hash type.
     #
     # @param hash [Hash] new headers
@@ -59,7 +62,7 @@ module Faraday
       if headers
         headers.replace hash
       else
-        super
+        member_set(:headers, hash)
       end
     end
 

data/lib/faraday/response/json.rb

@@ -11,6 +11,8 @@ module Faraday
         @parser_options = parser_options
         @content_types = Array(content_type)
         @preserve_raw = preserve_raw
+
+        process_parser_options
       end
 
       def on_complete(env)
@@ -27,7 +29,11 @@ module Faraday
       end
 
       def parse(body)
-        ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+        return if body.strip.empty?
+
+        decoder, method_name = @decoder_options
+
+        decoder.public_send(method_name, body, @parser_options || {})
       end
 
       def parse_response?(env)
@@ -47,6 +53,19 @@ module Faraday
         type = type.split(';', 2).first if type.index(';')
         type
       end
+
+      def process_parser_options
+        @decoder_options = @parser_options&.delete(:decoder)
+
+        @decoder_options =
+          if @decoder_options.is_a?(Array) && @decoder_options.size >= 2
+            @decoder_options.slice(0, 2)
+          elsif @decoder_options.respond_to?(:load)
+            [@decoder_options, :load]
+          else
+            [::JSON, :parse]
+          end
+      end
     end
   end
 end

data/lib/faraday/response/raise_error.rb

@@ -6,8 +6,8 @@ module Faraday
     # client or server error responses.
     class RaiseError < Middleware
       # rubocop:disable Naming/ConstantName
-      ClientErrorStatuses = (400...500).freeze
-      ServerErrorStatuses = (500...600).freeze
+      ClientErrorStatuses = (400...500)
+      ServerErrorStatuses = (500...600)
       # rubocop:enable Naming/ConstantName
 
       def on_complete(env)
@@ -24,10 +24,14 @@ module Faraday
           # mimic the behavior that we get with proxy requests with HTTPS
           msg = %(407 "Proxy Authentication Required")
           raise Faraday::ProxyAuthError.new(msg, response_values(env))
+        when 408
+          raise Faraday::RequestTimeoutError, response_values(env)
         when 409
           raise Faraday::ConflictError, response_values(env)
         when 422
           raise Faraday::UnprocessableEntityError, response_values(env)
+        when 429
+          raise Faraday::TooManyRequestsError, response_values(env)
         when ClientErrorStatuses
           raise Faraday::ClientError, response_values(env)
         when ServerErrorStatuses
@@ -37,11 +41,26 @@ module Faraday
         end
       end
 
+      # Returns a hash of response data with the following keys:
+      #   - status
+      #   - headers
+      #   - body
+      #   - request
+      #
+      # The `request` key is omitted when the middleware is explicitly
+      # configured with the option `include_request: false`.
       def response_values(env)
-        {
+        response = {
           status: env.status,
           headers: env.response_headers,
-          body: env.body,
+          body: env.body
+        }
+
+        # Include the request data by default. If the middleware was explicitly
+        # configured to _not_ include request data, then omit it.
+        return response unless options.fetch(:include_request, true)
+
+        response.merge(
           request: {
             method: env.method,
             url: env.url,
@@ -50,7 +69,7 @@ module Faraday
             headers: env.request_headers,
             body: env.request_body
           }
-        }
+        )
       end
 
       def query_params(env)

data/lib/faraday/utils.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
 require 'uri'
 require 'faraday/utils/headers'
 require 'faraday/utils/params_hash'
@@ -26,7 +25,7 @@ module Faraday
       attr_writer :default_space_encoding
     end
 
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 
     def escape(str)
       str.to_s.gsub(ESCAPE_RE) do |match|
@@ -38,7 +37,7 @@ module Faraday
       CGI.unescape str.to_s
     end
 
-    DEFAULT_SEP = /[&;] */n.freeze
+    DEFAULT_SEP = /[&;] */n
 
     # Adapted from Rack
     def parse_query(query)
@@ -54,7 +53,7 @@ module Faraday
     end
 
     def basic_header_from(login, pass)
-      value = Base64.encode64("#{login}:#{pass}")
+      value = ["#{login}:#{pass}"].pack('m') # Base64 encoding
       value.delete!("\n")
       "Basic #{value}"
     end

data/lib/faraday/version.rb

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

data/spec/faraday/error_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Faraday::ClientError do
+RSpec.describe Faraday::Error do
   describe '.initialize' do
     subject { described_class.new(exception, response) }
     let(:response) { nil }
@@ -12,8 +12,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq(exception.message) }
       it { expect(subject.backtrace).to eq(exception.backtrace) }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError wrapped=#<RuntimeError: test>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error wrapped=#<RuntimeError: test>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with response hash' do
@@ -22,8 +24,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(exception) }
       it { expect(subject.message).to eq('the server responded with status 400') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
       it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with string' do
@@ -32,8 +36,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: custom message>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error #<Faraday::Error: custom message>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with anything else #to_s' do
@@ -42,8 +48,10 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to be_nil }
       it { expect(subject.message).to eq('["error1", "error2"]') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError #<Faraday::ClientError: ["error1", "error2"]>>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error #<Faraday::Error: ["error1", "error2"]>>') }
       it { expect(subject.response_status).to be_nil }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
     end
 
     context 'with exception string and response hash' do
@@ -53,8 +61,25 @@ RSpec.describe Faraday::ClientError do
       it { expect(subject.wrapped_exception).to be_nil }
       it { expect(subject.response).to eq(response) }
       it { expect(subject.message).to eq('custom message') }
-      it { expect(subject.inspect).to eq('#<Faraday::ClientError response={:status=>400}>') }
+      it { expect(subject.inspect).to eq('#<Faraday::Error response={:status=>400}>') }
       it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to be_nil }
+      it { expect(subject.response_body).to be_nil }
+    end
+
+    context 'with exception and response object' do
+      let(:exception) { RuntimeError.new('test') }
+      let(:body) { { test: 'test' } }
+      let(:headers) { { 'Content-Type' => 'application/json' } }
+      let(:response) { Faraday::Response.new(status: 400, response_headers: headers, response_body: body) }
+
+      it { expect(subject.wrapped_exception).to eq(exception) }
+      it { expect(subject.response).to eq(response) }
+      it { expect(subject.message).to eq(exception.message) }
+      it { expect(subject.backtrace).to eq(exception.backtrace) }
+      it { expect(subject.response_status).to eq(400) }
+      it { expect(subject.response_headers).to eq(headers) }
+      it { expect(subject.response_body).to eq(body) }
     end
   end
 end

data/spec/faraday/options/options_spec.rb

@@ -2,7 +2,7 @@
 
 RSpec.describe Faraday::Options do
   SubOptions = Class.new(Faraday::Options.new(:sub_a, :sub_b))
-  class ParentOptions < Faraday::Options.new(:a, :b, :c)
+  ParentOptions = Faraday::Options.new(:a, :b, :c) do
     options c: SubOptions
   end
 

data/spec/faraday/options/proxy_options_spec.rb

@@ -32,6 +32,14 @@ RSpec.describe Faraday::ProxyOptions do
       expect(proxy.user).to be_nil
       expect(proxy.password).to be_nil
     end
+
+    it 'treats empty string as nil' do
+      proxy = nil
+      proxy_string = proxy.to_s # => empty string
+      options = Faraday::ProxyOptions.from proxy_string
+      expect(options).to be_a_kind_of(Faraday::ProxyOptions)
+      expect(options.inspect).to eq('#<Faraday::ProxyOptions (empty)>')
+    end
   end
 
   it 'allows hash access' do

data/spec/faraday/request/json_spec.rb

@@ -73,6 +73,30 @@ RSpec.describe Faraday::Request::Json do
     end
   end
 
+  context 'true body' do
+    let(:result) { process(true) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('true')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
+  context 'false body' do
+    let(:result) { process(false) }
+
+    it 'encodes body' do
+      expect(result_body).to eq('false')
+    end
+
+    it 'adds content type' do
+      expect(result_type).to eq('application/json')
+    end
+  end
+
   context 'object body with json type' do
     let(:result) { process({ a: 1 }, 'application/json; charset=utf-8') }
 
@@ -108,4 +132,68 @@ RSpec.describe Faraday::Request::Json do
       expect(result_type).to eq('application/xml; charset=utf-8')
     end
   end
+
+  context 'with encoder' do
+    let(:encoder) do
+      double('Encoder').tap do |e|
+        allow(e).to receive(:dump) { |s, opts| JSON.generate(s, opts) }
+      end
+    end
+
+    let(:result) { process(a: 1) }
+
+    context 'when encoder is passed as object' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: encoder }) }
+
+      it 'calls specified JSON encoder\'s dump method' do
+        expect(encoder).to receive(:dump).with({ a: 1 })
+
+        result
+      end
+
+      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 'when encoder is passed as an object-method pair' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }, { encoder: [encoder, :dump] }) }
+
+      it 'calls specified JSON encoder' do
+        expect(encoder).to receive(:dump).with({ a: 1 })
+
+        result
+      end
+
+      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 'when encoder is not passed' do
+      let(:middleware) { described_class.new(->(env) { Faraday::Response.new(env) }) }
+
+      it 'calls JSON.generate' do
+        expect(JSON).to receive(:generate).with({ a: 1 })
+
+        result
+      end
+
+      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
+  end
 end

data/spec/faraday/response/json_spec.rb

@@ -114,4 +114,76 @@ RSpec.describe Faraday::Response::Json, type: :response do
       expect(response.body).to eq(result)
     end
   end
+
+  context 'with decoder' do
+    let(:decoder) do
+      double('Decoder').tap do |e|
+        allow(e).to receive(:load) { |s, opts| JSON.parse(s, opts) }
+      end
+    end
+
+    let(:body) { '{"a": 1}' }
+    let(:result) { { a: 1 } }
+
+    context 'when decoder is passed as object' do
+      let(:options) do
+        {
+          parser_options: {
+            decoder: decoder,
+            option: :option_value,
+            symbolize_names: true
+          }
+        }
+      end
+
+      it 'passes relevant options to specified decoder\'s load method' do
+        expect(decoder).to receive(:load)
+          .with(body, { option: :option_value, symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      end
+    end
+
+    context 'when decoder is passed as an object-method pair' do
+      let(:options) do
+        {
+          parser_options: {
+            decoder: [decoder, :load],
+            option: :option_value,
+            symbolize_names: true
+          }
+        }
+      end
+
+      it 'passes relevant options to specified decoder\'s method' do
+        expect(decoder).to receive(:load)
+          .with(body, { option: :option_value, symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      end
+    end
+
+    context 'when decoder is not passed' do
+      let(:options) do
+        {
+          parser_options: {
+            symbolize_names: true
+          }
+        }
+      end
+
+      it 'passes relevant options to JSON parse' do
+        expect(JSON).to receive(:parse)
+          .with(body, { symbolize_names: true })
+          .and_return(result)
+
+        response = process(body)
+        expect(response.body).to eq(result)
+      end
+    end
+  end
 end

data/spec/faraday/response/logger_spec.rb

@@ -25,6 +25,7 @@ RSpec.describe Faraday::Response::Logger do
         stubs.get('/filtered_headers') { [200, { 'Content-Type' => 'text/html' }, 'headers response'] }
         stubs.get('/filtered_params') { [200, { 'Content-Type' => 'text/html' }, 'params response'] }
         stubs.get('/filtered_url') { [200, { 'Content-Type' => 'text/html' }, 'url response'] }
+        stubs.get('/connection_failed') { raise Faraday::ConnectionFailed, 'Failed to open TCP connection' }
       end
     end
   end
@@ -216,6 +217,15 @@ RSpec.describe Faraday::Response::Logger do
     end
   end
 
+  context 'when logging headers and errors' do
+    let(:logger_options) { { headers: true, errors: true } }
+
+    it 'logs error message' do
+      expect { conn.get '/connection_failed' }.to raise_error(Faraday::ConnectionFailed)
+      expect(string_io.string).to match(%(Failed to open TCP connection))
+    end
+  end
+
   context 'when using log_level' do
     let(:logger_options) { { bodies: true, log_level: :debug } }