faraday 1.10.3 → 2.7.10

data/lib/faraday/dependency_loader.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby2_keywords'
-
-module Faraday
-  # DependencyLoader helps Faraday adapters and middleware load dependencies.
-  module DependencyLoader
-    attr_reader :load_error
-
-    # Executes a block which should try to require and reference dependent
-    # libraries
-    def dependency(lib = nil)
-      lib ? require(lib) : yield
-    rescue LoadError, NameError => e
-      self.load_error = e
-    end
-
-    ruby2_keywords def new(*)
-      unless loaded?
-        raise "missing dependency for #{self}: #{load_error.message}"
-      end
-
-      super
-    end
-
-    def loaded?
-      load_error.nil?
-    end
-
-    def inherited(subclass)
-      super
-      subclass.send(:load_error=, load_error)
-    end
-
-    private
-
-    attr_writer :load_error
-  end
-end

data/lib/faraday/deprecate.rb

@@ -1,110 +0,0 @@
-# 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 replacement is present.
-    # @param ver [String] the semver the method will be removed.
-    def deprecate(name, repl, ver, custom_message = nil)
-      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} ",
-            custom_message,
-            "\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/basic_authentication.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module Faraday
-  class Request
-    # Authorization middleware for Basic Authentication.
-    class BasicAuthentication < load_middleware(:authorization)
-      # @param login [String]
-      # @param pass [String]
-      #
-      # @return [String] a Basic Authentication header line
-      def self.header(login, pass)
-        value = Base64.encode64([login, pass].join(':'))
-        value.delete!("\n")
-        super(:Basic, value)
-      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,49 +0,0 @@
-# frozen_string_literal: true
-
-unless defined?(JRUBY_VERSION)
-  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
-end

data/spec/faraday/adapter/em_synchrony_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-unless defined?(JRUBY_VERSION)
-  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
-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_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, unless: defined?(JRUBY_VERSION) 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

data/spec/faraday/adapter/typhoeus_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Adapter::Typhoeus do
-  features :request_body_on_query_methods, :parallel, :trace_method
-
-  it_behaves_like 'an adapter'
-end

data/spec/faraday/composite_read_io_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-
-RSpec.describe Faraday::CompositeReadIO do
-  Part = Struct.new(:to_io) do
-    def length
-      to_io.string.length
-    end
-  end
-
-  def part(str)
-    Part.new StringIO.new(str)
-  end
-
-  def composite_io(*parts)
-    Faraday::CompositeReadIO.new(*parts)
-  end
-
-  context 'with empty composite_io' do
-    subject { composite_io }
-
-    it { expect(subject.length).to eq(0) }
-    it { expect(subject.read).to eq('') }
-    it { expect(subject.read(1)).to be_nil }
-  end
-
-  context 'with empty parts' do
-    subject { composite_io(part(''), part('')) }
-
-    it { expect(subject.length).to eq(0) }
-    it { expect(subject.read).to eq('') }
-    it { expect(subject.read(1)).to be_nil }
-  end
-
-  context 'with 2 parts' do
-    subject { composite_io(part('abcd'), part('1234')) }
-
-    it { expect(subject.length).to eq(8) }
-    it { expect(subject.read).to eq('abcd1234') }
-    it 'allows to read in chunks' do
-      expect(subject.read(3)).to eq('abc')
-      expect(subject.read(3)).to eq('d12')
-      expect(subject.read(3)).to eq('34')
-      expect(subject.read(3)).to be_nil
-    end
-    it 'allows to rewind while reading in chunks' do
-      expect(subject.read(3)).to eq('abc')
-      expect(subject.read(3)).to eq('d12')
-      subject.rewind
-      expect(subject.read(3)).to eq('abc')
-      expect(subject.read(5)).to eq('d1234')
-      expect(subject.read(3)).to be_nil
-      subject.rewind
-      expect(subject.read(2)).to eq('ab')
-    end
-  end
-
-  context 'with mix of empty and non-empty parts' do
-    subject { composite_io(part(''), part('abcd'), part(''), part('1234'), part('')) }
-
-    it 'allows to read in chunks' do
-      expect(subject.read(6)).to eq('abcd12')
-      expect(subject.read(6)).to eq('34')
-      expect(subject.read(6)).to be_nil
-    end
-  end
-
-  context 'with utf8 multibyte part' do
-    subject { composite_io(part("\x86"), part('ファイル')) }
-
-    it { expect(subject.read).to eq(String.new("\x86\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB", encoding: 'BINARY')) }
-    it 'allows to read in chunks' do
-      expect(subject.read(3)).to eq(String.new("\x86\xE3\x83", encoding: 'BINARY'))
-      expect(subject.read(3)).to eq(String.new("\x95\xE3\x82", encoding: 'BINARY'))
-      expect(subject.read(8)).to eq(String.new("\xA1\xE3\x82\xA4\xE3\x83\xAB", encoding: 'BINARY'))
-      expect(subject.read(3)).to be_nil
-    end
-  end
-end