faraday 1.0.0 → 2.9.0

data/lib/faraday/request/multipart.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('url_encoded', __dir__)
-require 'securerandom'
-
-module Faraday
-  class Request
-    # Middleware for supporting multi-part requests.
-    class Multipart < UrlEncoded
-      self.mime_type = 'multipart/form-data'
-      unless defined? DEFAULT_BOUNDARY_PREFIX
-        DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
-      end
-
-      # Checks for files in the payload, otherwise leaves everything untouched.
-      #
-      # @param env [Faraday::Env]
-      def call(env)
-        match_content_type(env) do |params|
-          env.request.boundary ||= unique_boundary
-          env.request_headers[CONTENT_TYPE] +=
-            "; boundary=#{env.request.boundary}"
-          env.body = create_multipart(env, params)
-        end
-        @app.call env
-      end
-
-      # @param env [Faraday::Env]
-      def process_request?(env)
-        type = request_type(env)
-        env.body.respond_to?(:each_key) && !env.body.empty? && (
-          (type.empty? && has_multipart?(env.body)) ||
-          (type == self.class.mime_type)
-        )
-      end
-
-      # Returns true if obj is an enumerable with values that are multipart.
-      #
-      # @param obj [Object]
-      # @return [Boolean]
-      def has_multipart?(obj) # rubocop:disable Naming/PredicateName
-        if obj.respond_to?(:each)
-          (obj.respond_to?(:values) ? obj.values : obj).each do |val|
-            return true if val.respond_to?(:content_type) || has_multipart?(val)
-          end
-        end
-        false
-      end
-
-      # @param env [Faraday::Env]
-      # @param params [Hash]
-      def create_multipart(env, params)
-        boundary = env.request.boundary
-        parts = process_params(params) do |key, value|
-          part(boundary, key, value)
-        end
-        parts << Faraday::Parts::EpiloguePart.new(boundary)
-
-        body = Faraday::CompositeReadIO.new(parts)
-        env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
-        body
-      end
-
-      def part(boundary, key, value)
-        if value.respond_to?(:to_part)
-          value.to_part(boundary, key)
-        else
-          Faraday::Parts::Part.new(boundary, key, value)
-        end
-      end
-
-      # @return [String]
-      def unique_boundary
-        "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
-      end
-
-      # @param params [Hash]
-      # @param prefix [String]
-      # @param pieces [Array]
-      def process_params(params, prefix = nil, pieces = nil, &block)
-        params.inject(pieces || []) do |all, (key, value)|
-          key = "#{prefix}[#{key}]" if prefix
-
-          case value
-          when Array
-            values = value.inject([]) { |a, v| a << [nil, v] }
-            process_params(values, key, all, &block)
-          when Hash
-            process_params(value, key, all, &block)
-          else
-            # rubocop:disable Performance/RedundantBlockCall
-            all << block.call(key, value)
-            # rubocop:enable Performance/RedundantBlockCall
-          end
-        end
-      end
-    end
-  end
-end

data/lib/faraday/request/retry.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Request
-    # Catches exceptions and retries each request a limited number of times.
-    #
-    # By default, it retries 2 times and handles only timeout exceptions. It can
-    # be configured with an arbitrary number of retries, a list of exceptions to
-    # handle, a retry interval, a percentage of randomness to add to the retry
-    # interval, and a backoff factor.
-    #
-    # @example Configure Retry middleware using intervals
-    #   Faraday.new do |conn|
-    #     conn.request(:retry, max: 2,
-    #                          interval: 0.05,
-    #                          interval_randomness: 0.5,
-    #                          backoff_factor: 2,
-    #                          exceptions: [CustomException, 'Timeout::Error'])
-    #
-    #     conn.adapter(:net_http) # NB: Last middleware must be the adapter
-    #   end
-    #
-    # This example will result in a first interval that is random between 0.05
-    # and 0.075 and a second interval that is random between 0.1 and 0.15.
-    class Retry < Faraday::Middleware
-      DEFAULT_EXCEPTIONS = [
-        Errno::ETIMEDOUT, 'Timeout::Error',
-        Faraday::TimeoutError, Faraday::RetriableResponse
-      ].freeze
-      IDEMPOTENT_METHODS = %i[delete get head options put].freeze
-
-      # Options contains the configurable parameters for the Retry middleware.
-      class Options < Faraday::Options.new(:max, :interval, :max_interval,
-                                           :interval_randomness,
-                                           :backoff_factor, :exceptions,
-                                           :methods, :retry_if, :retry_block,
-                                           :retry_statuses)
-
-        DEFAULT_CHECK = ->(_env, _exception) { false }
-
-        def self.from(value)
-          if value.is_a?(Integer)
-            new(value)
-          else
-            super(value)
-          end
-        end
-
-        def max
-          (self[:max] ||= 2).to_i
-        end
-
-        def interval
-          (self[:interval] ||= 0).to_f
-        end
-
-        def max_interval
-          (self[:max_interval] ||= Float::MAX).to_f
-        end
-
-        def interval_randomness
-          (self[:interval_randomness] ||= 0).to_f
-        end
-
-        def backoff_factor
-          (self[:backoff_factor] ||= 1).to_f
-        end
-
-        def exceptions
-          Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
-        end
-
-        def methods
-          Array(self[:methods] ||= IDEMPOTENT_METHODS)
-        end
-
-        def retry_if
-          self[:retry_if] ||= DEFAULT_CHECK
-        end
-
-        def retry_block
-          self[:retry_block] ||= proc {}
-        end
-
-        def retry_statuses
-          Array(self[:retry_statuses] ||= [])
-        end
-      end
-
-      # @param app [#call]
-      # @param options [Hash]
-      # @option options [Integer] :max (2) Maximum number of retries
-      # @option options [Integer] :interval (0) Pause in seconds between retries
-      # @option options [Integer] :interval_randomness (0) The maximum random
-      #   interval amount expressed as a float between
-      #   0 and 1 to use in addition to the interval.
-      # @option options [Integer] :max_interval (Float::MAX) An upper limit
-      #   for the interval
-      # @option options [Integer] :backoff_factor (1) The amount to multiply
-      #   each successive retry's interval amount by in order to provide backoff
-      # @option options [Array] :exceptions ([ Errno::ETIMEDOUT,
-      #   'Timeout::Error', Faraday::TimeoutError, Faraday::RetriableResponse])
-      #   The list of exceptions to handle. Exceptions can be given as
-      #   Class, Module, or String.
-      # @option options [Array] :methods (the idempotent HTTP methods
-      #   in IDEMPOTENT_METHODS) A list of HTTP methods to retry without
-      #   calling retry_if. Pass an empty Array to call retry_if
-      #   for all exceptions.
-      # @option options [Block] :retry_if (false) block that will receive
-      #   the env object and the exception raised
-      #   and should decide if the code should retry still the action or
-      #   not independent of the retry count. This would be useful
-      #   if the exception produced is non-recoverable or if the
-      #   the HTTP method called is not idempotent.
-      # @option options [Block] :retry_block block that is executed after
-      #   every retry. Request environment, middleware options, current number
-      #   of retries and the exception is passed to the block as parameters.
-      # @option options [Array] :retry_statuses Array of Integer HTTP status
-      #   codes or a single Integer value that determines whether to raise
-      #   a Faraday::RetriableResponse exception based on the HTTP status code
-      #   of an HTTP response.
-      def initialize(app, options = nil)
-        super(app)
-        @options = Options.from(options)
-        @errmatch = build_exception_matcher(@options.exceptions)
-      end
-
-      def calculate_sleep_amount(retries, env)
-        retry_after = calculate_retry_after(env)
-        retry_interval = calculate_retry_interval(retries)
-
-        return if retry_after && retry_after > @options.max_interval
-
-        if retry_after && retry_after >= retry_interval
-          retry_after
-        else
-          retry_interval
-        end
-      end
-
-      # @param env [Faraday::Env]
-      def call(env)
-        retries = @options.max
-        request_body = env[:body]
-        begin
-          # after failure env[:body] is set to the response body
-          env[:body] = request_body
-          @app.call(env).tap do |resp|
-            if @options.retry_statuses.include?(resp.status)
-              raise Faraday::RetriableResponse.new(nil, resp)
-            end
-          end
-        rescue @errmatch => e
-          if retries.positive? && retry_request?(env, e)
-            retries -= 1
-            rewind_files(request_body)
-            @options.retry_block.call(env, @options, retries, e)
-            if (sleep_amount = calculate_sleep_amount(retries + 1, env))
-              sleep sleep_amount
-              retry
-            end
-          end
-
-          raise unless e.is_a?(Faraday::RetriableResponse)
-
-          e.response
-        end
-      end
-
-      # An exception matcher for the rescue clause can usually be any object
-      # that responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
-      #
-      # @param exceptions [Array]
-      # @api private
-      # @return [Module] an exception matcher
-      def build_exception_matcher(exceptions)
-        matcher = Module.new
-        (
-        class << matcher
-          self
-        end).class_eval do
-          define_method(:===) do |error|
-            exceptions.any? do |ex|
-              if ex.is_a? Module
-                error.is_a? ex
-              else
-                error.class.to_s == ex.to_s
-              end
-            end
-          end
-        end
-        matcher
-      end
-
-      private
-
-      def retry_request?(env, exception)
-        @options.methods.include?(env[:method]) ||
-          @options.retry_if.call(env, exception)
-      end
-
-      def rewind_files(body)
-        return unless body.is_a?(Hash)
-
-        body.each do |_, value|
-          value.rewind if value.is_a?(UploadIO)
-        end
-      end
-
-      # MDN spec for Retry-After header:
-      # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
-      def calculate_retry_after(env)
-        response_headers = env[:response_headers]
-        return unless response_headers
-
-        retry_after_value = env[:response_headers]['Retry-After']
-
-        # Try to parse date from the header value
-        begin
-          datetime = DateTime.rfc2822(retry_after_value)
-          datetime.to_time - Time.now.utc
-        rescue ArgumentError
-          retry_after_value.to_f
-        end
-      end
-
-      def calculate_retry_interval(retries)
-        retry_index = @options.max - retries
-        current_interval = @options.interval *
-                           (@options.backoff_factor**retry_index)
-        current_interval = [current_interval, @options.max_interval].min
-        random_interval = rand * @options.interval_randomness.to_f *
-                          @options.interval
-
-        current_interval + random_interval
-      end
-    end
-  end
-end

data/lib/faraday/request/token_authentication.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Request
-    # TokenAuthentication is a middleware that adds a 'Token' header to a
-    # Faraday request.
-    class TokenAuthentication < load_middleware(:authorization)
-      # Public
-      def self.header(token, options = nil)
-        options ||= {}
-        options[:token] = token
-        super(:Token, options)
-      end
-
-      def initialize(app, token, options = nil)
-        super(app, token, options)
-      end
-    end
-  end
-end

data/spec/faraday/adapter/em_http_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::EMHttp do
-  features :request_body_on_query_methods, :reason_phrase_parse, :trace_method,
-           :skip_response_body_on_head, :parallel, :local_socket_binding
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    url = URI('https://example.com:1234')
-    adapter = described_class.new nil, inactivity_timeout: 20
-    req = adapter.create_request(url: url, request: {})
-
-    expect(req.connopts.inactivity_timeout).to eq(20)
-  end
-
-  context 'Options' do
-    let(:request) { Faraday::RequestOptions.new }
-    let(:env) { { request: request } }
-    let(:options) { {} }
-    let(:adapter) { Faraday::Adapter::EMHttp.new }
-
-    it 'configures timeout' do
-      request.timeout = 5
-      adapter.configure_timeout(options, env)
-      expect(options[:inactivity_timeout]).to eq(5)
-      expect(options[:connect_timeout]).to eq(5)
-    end
-
-    it 'configures timeout and open_timeout' do
-      request.timeout = 5
-      request.open_timeout = 1
-      adapter.configure_timeout(options, env)
-      expect(options[:inactivity_timeout]).to eq(5)
-      expect(options[:connect_timeout]).to eq(1)
-    end
-
-    it 'configures all timeout settings' do
-      request.timeout = 5
-      request.read_timeout = 3
-      request.open_timeout = 1
-      adapter.configure_timeout(options, env)
-      expect(options[:inactivity_timeout]).to eq(3)
-      expect(options[:connect_timeout]).to eq(1)
-    end
-  end
-end

data/spec/faraday/adapter/em_synchrony_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::EMSynchrony do
-  features :request_body_on_query_methods, :reason_phrase_parse,
-           :skip_response_body_on_head, :parallel, :local_socket_binding
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    url = URI('https://example.com:1234')
-    adapter = described_class.new nil, inactivity_timeout: 20
-    req = adapter.create_request(url: url, request: {})
-
-    expect(req.connopts.inactivity_timeout).to eq(20)
-  end
-end

data/spec/faraday/adapter/excon_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Excon do
-  features :request_body_on_query_methods, :reason_phrase_parse, :trace_method
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    url = URI('https://example.com:1234')
-
-    adapter = described_class.new(nil, debug_request: true)
-
-    conn = adapter.build_connection(url: url)
-
-    expect(conn.data[:debug_request]).to be_truthy
-  end
-
-  context 'config' do
-    let(:adapter) { Faraday::Adapter::Excon.new }
-    let(:request) { Faraday::RequestOptions.new }
-    let(:uri) { URI.parse('https://example.com') }
-    let(:env) { { request: request, url: uri } }
-
-    it 'sets timeout' do
-      request.timeout = 5
-      options = adapter.send(:opts_from_env, env)
-      expect(options[:read_timeout]).to eq(5)
-      expect(options[:write_timeout]).to eq(5)
-      expect(options[:connect_timeout]).to eq(5)
-    end
-
-    it 'sets timeout and open_timeout' do
-      request.timeout = 5
-      request.open_timeout = 3
-      options = adapter.send(:opts_from_env, env)
-      expect(options[:read_timeout]).to eq(5)
-      expect(options[:write_timeout]).to eq(5)
-      expect(options[:connect_timeout]).to eq(3)
-    end
-
-    it 'sets open_timeout' do
-      request.open_timeout = 3
-      options = adapter.send(:opts_from_env, env)
-      expect(options[:read_timeout]).to eq(nil)
-      expect(options[:write_timeout]).to eq(nil)
-      expect(options[:connect_timeout]).to eq(3)
-    end
-  end
-end

data/spec/faraday/adapter/httpclient_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::HTTPClient do
-  # ruby gem defaults for testing purposes
-  HTTPCLIENT_OPEN = 60
-  HTTPCLIENT_READ = 60
-  HTTPCLIENT_WRITE = 120
-
-  features :request_body_on_query_methods, :reason_phrase_parse, :compression,
-           :trace_method, :local_socket_binding
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    adapter = described_class.new do |client|
-      client.keep_alive_timeout = 20
-      client.ssl_config.timeout = 25
-    end
-
-    client = adapter.build_connection(url: URI.parse('https://example.com'))
-    expect(client.keep_alive_timeout).to eq(20)
-    expect(client.ssl_config.timeout).to eq(25)
-  end
-
-  context 'Options' do
-    let(:request) { Faraday::RequestOptions.new }
-    let(:env) { { request: request } }
-    let(:options) { {} }
-    let(:adapter) { Faraday::Adapter::HTTPClient.new }
-    let(:client) { adapter.connection(url: URI.parse('https://example.com')) }
-
-    it 'configures timeout' do
-      assert_default_timeouts!
-
-      request.timeout = 5
-      adapter.configure_timeouts(client, request)
-
-      expect(client.connect_timeout).to eq(5)
-      expect(client.send_timeout).to eq(5)
-      expect(client.receive_timeout).to eq(5)
-    end
-
-    it 'configures open timeout' do
-      assert_default_timeouts!
-
-      request.open_timeout = 1
-      adapter.configure_timeouts(client, request)
-
-      expect(client.connect_timeout).to eq(1)
-      expect(client.send_timeout).to eq(HTTPCLIENT_WRITE)
-      expect(client.receive_timeout).to eq(HTTPCLIENT_READ)
-    end
-
-    it 'configures multiple timeouts' do
-      assert_default_timeouts!
-
-      request.open_timeout = 1
-      request.write_timeout = 10
-      request.read_timeout = 5
-      adapter.configure_timeouts(client, request)
-
-      expect(client.connect_timeout).to eq(1)
-      expect(client.send_timeout).to eq(10)
-      expect(client.receive_timeout).to eq(5)
-    end
-
-    def assert_default_timeouts!
-      expect(client.connect_timeout).to eq(HTTPCLIENT_OPEN)
-      expect(client.send_timeout).to eq(HTTPCLIENT_WRITE)
-      expect(client.receive_timeout).to eq(HTTPCLIENT_READ)
-    end
-  end
-end

data/spec/faraday/adapter/net_http_persistent_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::NetHttpPersistent do
-  features :request_body_on_query_methods, :reason_phrase_parse, :compression, :trace_method
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    url = URI('https://example.com')
-
-    adapter = described_class.new do |http|
-      http.idle_timeout = 123
-    end
-
-    http = adapter.send(:connection, url: url, request: {})
-    adapter.send(:configure_request, http, {})
-
-    expect(http.idle_timeout).to eq(123)
-  end
-
-  it 'sets max_retries to 0' do
-    url = URI('http://example.com')
-
-    adapter = described_class.new
-
-    http = adapter.send(:connection, url: url, request: {})
-    adapter.send(:configure_request, http, {})
-
-    # `max_retries=` is only present in Ruby 2.5
-    expect(http.max_retries).to eq(0) if http.respond_to?(:max_retries=)
-  end
-
-  it 'allows to set pool_size on initialize' do
-    url = URI('https://example.com')
-
-    adapter = described_class.new(nil, pool_size: 5)
-
-    http = adapter.send(:connection, url: url, request: {})
-
-    # `pool` is only present in net_http_persistent >= 3.0
-    expect(http.pool.size).to eq(5) if http.respond_to?(:pool)
-  end
-
-  context 'min_version' do
-    it 'allows to set min_version in SSL settings' do
-      url = URI('https://example.com')
-
-      adapter = described_class.new(nil)
-
-      http = adapter.send(:connection, url: url, request: {})
-      adapter.send(:configure_ssl, http, min_version: :TLS1_2)
-
-      # `min_version` is only present in net_http_persistent >= 3.1 (UNRELEASED)
-      expect(http.min_version).to eq(:TLS1_2) if http.respond_to?(:min_version)
-    end
-  end
-end

data/spec/faraday/adapter/net_http_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::NetHttp do
-  features :request_body_on_query_methods, :reason_phrase_parse, :compression, :streaming, :trace_method
-
-  it_behaves_like 'an adapter'
-
-  context 'checking http' do
-    let(:url) { URI('http://example.com') }
-    let(:adapter) { described_class.new }
-    let(:http) { adapter.send(:connection, url: url, request: {}) }
-
-    it { expect(http.port).to eq(80) }
-
-    it 'sets max_retries to 0' do
-      adapter.send(:configure_request, http, {})
-
-      expect(http.max_retries).to eq(0) if http.respond_to?(:max_retries=)
-    end
-
-    it 'supports write_timeout' do
-      adapter.send(:configure_request, http, write_timeout: 10)
-
-      expect(http.write_timeout).to eq(10) if http.respond_to?(:write_timeout=)
-    end
-
-    it 'supports open_timeout' do
-      adapter.send(:configure_request, http, open_timeout: 10)
-
-      expect(http.open_timeout).to eq(10)
-    end
-
-    it 'supports read_timeout' do
-      adapter.send(:configure_request, http, read_timeout: 10)
-
-      expect(http.read_timeout).to eq(10)
-    end
-
-    context 'with https url' do
-      let(:url) { URI('https://example.com') }
-
-      it { expect(http.port).to eq(443) }
-    end
-
-    context 'with http url including port' do
-      let(:url) { URI('https://example.com:1234') }
-
-      it { expect(http.port).to eq(1234) }
-    end
-
-    context 'with custom adapter config' do
-      let(:adapter) do
-        described_class.new do |http|
-          http.continue_timeout = 123
-        end
-      end
-
-      it do
-        adapter.send(:configure_request, http, {})
-        expect(http.continue_timeout).to eq(123)
-      end
-    end
-  end
-end

data/spec/faraday/adapter/patron_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Patron do
-  features :reason_phrase_parse
-
-  it_behaves_like 'an adapter'
-
-  it 'allows to provide adapter specific configs' do
-    conn = Faraday.new do |f|
-      f.adapter :patron do |session|
-        session.max_redirects = 10
-        raise 'Configuration block called'
-      end
-    end
-
-    expect { conn.get('/') }.to raise_error(RuntimeError, 'Configuration block called')
-  end
-end

data/spec/faraday/adapter/rack_spec.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Rack do
-  features :request_body_on_query_methods, :trace_method,
-           :skip_response_body_on_head
-
-  it_behaves_like 'an adapter', adapter_options: WebmockRackApp.new
-end