faraday 1.3.0 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f907e999805c78e8c2e77cb4d6b29a0a6f8fd8fe1a7df9930f02be7ec113a630
-  data.tar.gz: 1ceac7f2b44d41d11d1ad3f7642daea9198ba3ac2f71a4932cf7d6b7b867f704
+  metadata.gz: bc82ee913ef4ffa6468eea5e656c49d4eab0f769321eb63a85fdb4caa9a90143
+  data.tar.gz: cccf1ae40f10f353ca2cc5e4e92bb01e4b1d65a9ac3ed50b7e5c5951680ba019
 SHA512:
-  metadata.gz: 2eaf54d743ed3d7554fb2be17003e81b08c060582f140b06fb55e8aceb7dfcf2428e898f47f3760eddcdb4ad64aeaacc93916672b9ed10fa4a004d0ea1a20e1a
-  data.tar.gz: a700f0bc8999e9a0152843bbfbd23001fa23931614ae9573b13ff839e7af01f38ca2adbb01c82e4b387688496b3caff87357e3946d7500595a2f807313e177d7
+  metadata.gz: 5360375fef63ad3e1068792458dd8ccc956b603be65e5571b9b6ce73938fc7ba2d220aeb99d4f3b022fa9945a07c8264c6452916e58963883fdd6843ded2d58e
+  data.tar.gz: fac76254509856e7e827fecda3c76a070c53cdb1771782ff5d668f14a4b8a4b126be9761d0856fe28eccda4607daf031cb7c8ea4559e245b100db08e95f01a0a

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Faraday Changelog
 
+## [v1.3.0](https://github.com/lostisland/faraday/releases/tag/v1.3.0) (2020-12-31)
+
+### Highlights
+Faraday v1.3.0 is the first release to officially support Ruby 3.0 in the CI pipeline 🎉 🍾! 
+
+This is also the first release with a previously "included" adapter (Net::HTTP) being isolated into a [separate gem](https://github.com/lostisland/faraday-net_http) 🎊!
+The new adapter is added to Faraday as a dependency for now, so that means full backwards-compatibility, but just to be safe be careful when upgrading!
+
+This is a huge step towards are Faraday v2.0 objective of pushing adapters and middleware into separate gems.
+Many thanks to the Faraday Team, @JanDintel and everyone who attended the [ROSS Conf remote event](https://www.rossconf.io/event/remote/)
+
+### Features
+
+* Improves consistency with Faraday::Error and Faraday::RaiseError (#1229, @qsona, @iMacTia)
+
+### Fixes
+
+* Don't assign to global ::Timer (#1227, @bpo)
+
+### Documentation
+
+* CHANGELOG: add releases after 1.0 (#1225, @olleolleolle)
+* Improves retry middleware documentation. (#1228, @iMacTia)
+
+### Misc
+
+* Move out Net::HTTP adapter (#1222, @JanDintel, @iMacTia)
+* Adds Ruby 3.0 to CI Matrix (#1226, @iMacTia)
+
+
 ## [v1.2.0](https://github.com/lostisland/faraday/releases/tag/v1.2.0) (2020-12-23)
 
 ### Features

data/README.md

@@ -2,7 +2,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/faraday.svg)](https://rubygems.org/gems/faraday)
 [![GitHub Actions CI](https://github.com/lostisland/faraday/workflows/CI/badge.svg)](https://github.com/lostisland/faraday/actions?query=workflow%3ACI)
-[![Maintainability](https://api.codeclimate.com/v1/badges/f869daab091ceef1da73/maintainability)](https://codeclimate.com/github/lostisland/faraday/maintainability)
 [![Gitter](https://badges.gitter.im/lostisland/faraday.svg)](https://gitter.im/lostisland/faraday?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 
@@ -47,7 +46,7 @@ But before you start coding, please read our [Contributing Guide][contributing]
 [website]:      https://lostisland.github.io/faraday
 [faraday_team]: https://lostisland.github.io/faraday/team
 [contributing]: https://github.com/lostisland/faraday/blob/master/.github/CONTRIBUTING.md
-[apidoc]:       http://www.rubydoc.info/gems/faraday
+[apidoc]:       https://www.rubydoc.info/github/lostisland/faraday
 [actions]:      https://github.com/lostisland/faraday/actions
 [jruby]:        http://jruby.org/
 [rubinius]:     http://rubini.us/

data/lib/faraday.rb

@@ -27,7 +27,11 @@ require 'faraday/error'
 require 'faraday/file_part'
 require 'faraday/param_part'
 
+require 'faraday/em_http'
+require 'faraday/em_synchrony'
+require 'faraday/excon'
 require 'faraday/net_http'
+require 'faraday/net_http_persistent'
 
 # This is the main namespace for Faraday.
 #

data/lib/faraday/adapter.rb

@@ -11,15 +11,8 @@ module Faraday
 
     register_middleware File.expand_path('adapter', __dir__),
                         test: [:Test, 'test'],
-                        net_http_persistent: [
-                          :NetHttpPersistent,
-                          'net_http_persistent'
-                        ],
                         typhoeus: [:Typhoeus, 'typhoeus'],
                         patron: [:Patron, 'patron'],
-                        em_synchrony: [:EMSynchrony, 'em_synchrony'],
-                        em_http: [:EMHttp, 'em_http'],
-                        excon: [:Excon, 'excon'],
                         rack: [:Rack, 'rack'],
                         httpclient: [:HTTPClient, 'httpclient']
 

data/lib/faraday/autoload.rb

@@ -58,12 +58,8 @@ module Faraday
   class Adapter
     extend AutoloadHelper
     autoload_all 'faraday/adapter',
-                 NetHttpPersistent: 'net_http_persistent',
-                 EMSynchrony: 'em_synchrony',
-                 EMHttp: 'em_http',
                  Typhoeus: 'typhoeus',
                  Patron: 'patron',
-                 Excon: 'excon',
                  Test: 'test',
                  Rack: 'rack',
                  HTTPClient: 'httpclient'

data/lib/faraday/connection.rb

@@ -73,6 +73,7 @@ module Faraday
       @options = options.request
       @ssl = options.ssl
       @default_parallel_manager = options.parallel_manager
+      @manual_proxy = nil
 
       @builder = options.builder || begin
         # pass an empty block to Builder so it doesn't assume default middleware
@@ -419,6 +420,8 @@ module Faraday
         basic_auth user, password
         uri.user = uri.password = nil
       end
+
+      @proxy = proxy_from_env(url) unless @manual_proxy
     end
 
     # Sets the path prefix and ensures that it always has a leading
@@ -517,11 +520,11 @@ module Faraday
     # @return [URI]
     def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
       url = nil if url.respond_to?(:empty?) && url.empty?
-      base = url_prefix
+      base = url_prefix.dup
       if url && base.path && base.path !~ %r{/$}
-        base = base.dup
         base.path = "#{base.path}/" # ensure trailing slash
       end
+      url = url && URI.parse(url.to_s).opaque ? url.to_s.gsub(':', '%3A') : url
       uri = url ? base + url : base
       if params
         uri.query = params.to_query(params_encoder || options.params_encoder)
@@ -576,7 +579,11 @@ module Faraday
         case url
         when String
           uri = Utils.URI(url)
-          uri = URI.parse("#{uri.scheme}://#{uri.hostname}").find_proxy
+          uri = if uri.host.nil?
+                  find_default_proxy
+                else
+                  URI.parse("#{uri.scheme}://#{uri.host}").find_proxy
+                end
         when URI
           uri = url.find_proxy
         when nil

data/lib/faraday/options/proxy_options.rb

@@ -11,6 +11,9 @@ module Faraday
     def self.from(value)
       case value
       when String
+        # URIs without a scheme should default to http (like 'example:123').
+        # This fixes #1282 and prevents a silent failure in some adapters.
+        value = "http://#{value}" unless value.include?('://')
         value = { uri: Utils.URI(value) }
       when URI
         value = { uri: value }
@@ -19,6 +22,7 @@ module Faraday
           value[:uri] = Utils.URI(uri)
         end
       end
+
       super(value)
     end
 

data/lib/faraday/version.rb

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

data/spec/faraday/connection_spec.rb

@@ -18,6 +18,13 @@ shared_examples 'initializer with url' do
     it { expect(subject.path_prefix).to eq('/fish') }
     it { expect(subject.params).to eq('a' => '1') }
   end
+
+  context 'with IPv6 address' do
+    let(:address) { 'http://[::1]:85/' }
+
+    it { expect(subject.host).to eq('[::1]') }
+    it { expect(subject.port).to eq(85) }
+  end
 end
 
 shared_examples 'default connection options' do
@@ -246,6 +253,13 @@ RSpec.describe Faraday::Connection do
       expect(uri.path).to eq('/sake.html')
     end
 
+    it 'always returns new URI instance' do
+      conn.url_prefix = 'http://sushi.com'
+      uri1 = conn.build_exclusive_url(nil)
+      uri2 = conn.build_exclusive_url(nil)
+      expect(uri1).not_to equal(uri2)
+    end
+
     context 'with url_prefixed connection' do
       let(:url) { 'http://sushi.com/sushi/' }
 
@@ -270,6 +284,29 @@ RSpec.describe Faraday::Connection do
         expect(uri.to_s).to eq('http://sushi.com/sake/')
       end
     end
+
+    context 'with colon in path' do
+      let(:url) { 'http://service.com' }
+
+      it 'joins url to base when used absolute path' do
+        conn = Faraday.new(url: url)
+        uri = conn.build_exclusive_url('/service:search?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service:search?limit=400')
+      end
+
+      it 'joins url to base when used relative path' do
+        conn = Faraday.new(url: url)
+        uri = conn.build_exclusive_url('service:search?limit=400')
+        expect(uri.to_s).to eq('http://service.com/service%3Asearch?limit=400')
+      end
+
+      it 'joins url to base when used with path prefix' do
+        conn = Faraday.new(url: url)
+        conn.path_prefix = '/api'
+        uri = conn.build_exclusive_url('service:search?limit=400')
+        expect(uri.to_s).to eq('http://service.com/api/service%3Asearch?limit=400')
+      end
+    end
   end
 
   describe '#build_url' do
@@ -412,6 +449,14 @@ RSpec.describe Faraday::Connection do
       end
     end
 
+    it 'allows when url in no proxy list with url_prefix' do
+      with_env 'http_proxy' => 'http://proxy.com', 'no_proxy' => 'example.com' do
+        conn = Faraday::Connection.new
+        conn.url_prefix = 'http://example.com'
+        expect(conn.proxy).to be_nil
+      end
+    end
+
     it 'allows when prefixed url is not in no proxy list' do
       with_env 'http_proxy' => 'http://proxy.com', 'no_proxy' => 'example.com' do
         conn = Faraday::Connection.new('http://prefixedexample.com')

data/spec/faraday/options/proxy_options_spec.rb

@@ -14,6 +14,13 @@ RSpec.describe Faraday::ProxyOptions do
       expect(options.inspect).to match('#<Faraday::ProxyOptions uri=')
     end
 
+    it 'defaults to http' do
+      options = Faraday::ProxyOptions.from 'example.org'
+      expect(options.port).to eq(80)
+      expect(options.host).to eq('example.org')
+      expect(options.scheme).to eq('http')
+    end
+
     it 'works with nil' do
       options = Faraday::ProxyOptions.from nil
       expect(options).to be_a_kind_of(Faraday::ProxyOptions)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faraday
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.3
 platform: ruby
 authors:
 - "@technoweenie"
@@ -10,8 +10,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-31 00:00:00.000000000 Z
+date: 2021-06-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday-em_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-em_synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: faraday-net_http
   requirement: !ruby/object:Gem::Requirement
@@ -26,6 +68,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-net_http_persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: multipart-post
   requirement: !ruby/object:Gem::Requirement
@@ -52,14 +108,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.4
 description: 
 email: technoweenie@gmail.com
 executables: []
@@ -74,13 +130,7 @@ files:
 - examples/client_test.rb
 - lib/faraday.rb
 - lib/faraday/adapter.rb
-- lib/faraday/adapter/em_http.rb
-- lib/faraday/adapter/em_http_ssl_patch.rb
-- lib/faraday/adapter/em_synchrony.rb
-- lib/faraday/adapter/em_synchrony/parallel_manager.rb
-- lib/faraday/adapter/excon.rb
 - lib/faraday/adapter/httpclient.rb
-- lib/faraday/adapter/net_http_persistent.rb
 - lib/faraday/adapter/patron.rb
 - lib/faraday/adapter/rack.rb
 - lib/faraday/adapter/test.rb
@@ -126,7 +176,6 @@ files:
 - spec/faraday/adapter/em_synchrony_spec.rb
 - spec/faraday/adapter/excon_spec.rb
 - spec/faraday/adapter/httpclient_spec.rb
-- spec/faraday/adapter/net_http_persistent_spec.rb
 - spec/faraday/adapter/net_http_spec.rb
 - spec/faraday/adapter/patron_spec.rb
 - spec/faraday/adapter/rack_spec.rb
@@ -172,7 +221,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://lostisland.github.io/faraday
-  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v1.3.0
+  changelog_uri: https://github.com/lostisland/faraday/releases/tag/v1.4.3
   source_code_uri: https://github.com/lostisland/faraday
   bug_tracker_uri: https://github.com/lostisland/faraday/issues
 post_install_message: 
@@ -191,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: HTTP/REST API client library.

data/lib/faraday/adapter/em_http.rb

@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # EventMachine adapter. This adapter is useful for either asynchronous
-    # requests when in an EM reactor loop, or for making parallel requests in
-    # synchronous code.
-    class EMHttp < Faraday::Adapter
-      # Options is a module containing helpers to convert the Faraday env object
-      # into options hashes for EMHTTP method calls.
-      module Options
-        # @return [Hash]
-        def connection_config(env)
-          options = {}
-          configure_proxy(options, env)
-          configure_timeout(options, env)
-          configure_socket(options, env)
-          configure_ssl(options, env)
-          options
-        end
-
-        def request_config(env)
-          options = {
-            body: read_body(env),
-            head: env[:request_headers]
-            # keepalive: true,
-            # file: 'path/to/file', # stream data off disk
-          }
-          configure_compression(options, env)
-          options
-        end
-
-        def read_body(env)
-          body = env[:body]
-          body.respond_to?(:read) ? body.read : body
-        end
-
-        # Reads out proxy settings from env into options
-        def configure_proxy(options, env)
-          proxy = request_options(env)[:proxy]
-          return unless proxy
-
-          options[:proxy] = {
-            host: proxy[:uri].host,
-            port: proxy[:uri].port,
-            authorization: [proxy[:user], proxy[:password]]
-          }
-        end
-
-        # Reads out host and port settings from env into options
-        def configure_socket(options, env)
-          bind = request_options(env)[:bind]
-          return unless bind
-
-          options[:bind] = {
-            host: bind[:host],
-            port: bind[:port]
-          }
-        end
-
-        # Reads out SSL certificate settings from env into options
-        def configure_ssl(options, env)
-          return unless env[:url].scheme == 'https' && env[:ssl]
-
-          options[:ssl] = {
-            cert_chain_file: env[:ssl][:ca_file],
-            verify_peer: env[:ssl].fetch(:verify, true)
-          }
-        end
-
-        # Reads out timeout settings from env into options
-        def configure_timeout(options, env)
-          req = request_options(env)
-          options[:inactivity_timeout] = request_timeout(:read, req)
-          options[:connect_timeout] = request_timeout(:open, req)
-        end
-
-        # Reads out compression header settings from env into options
-        def configure_compression(options, env)
-          return unless (env[:method] == :get) &&
-                        !options[:head].key?('accept-encoding')
-
-          options[:head]['accept-encoding'] = 'gzip, compressed'
-        end
-
-        def request_options(env)
-          env[:request]
-        end
-      end
-
-      include Options
-
-      dependency do
-        require 'em-http'
-
-        begin
-          require 'openssl'
-        rescue LoadError
-          warn 'Warning: no such file to load -- openssl. ' \
-            'Make sure it is installed if you want HTTPS support'
-        else
-          require 'em-http/version'
-          if EventMachine::HttpRequest::VERSION < '1.1.6'
-            require 'faraday/adapter/em_http_ssl_patch'
-          end
-        end
-      end
-
-      self.supports_parallel = true
-
-      # @return [Manager]
-      def self.setup_parallel_manager(_options = nil)
-        Manager.new
-      end
-
-      def call(env)
-        super
-        perform_request env
-        @app.call env
-      end
-
-      def perform_request(env)
-        if parallel?(env)
-          manager = env[:parallel_manager]
-          manager.add do
-            perform_single_request(env)
-              .callback { env[:response].finish(env) }
-          end
-        elsif EventMachine.reactor_running?
-          # EM is running: instruct upstream that this is an async request
-          env[:parallel_manager] = true
-          perform_single_request(env)
-            .callback { env[:response].finish(env) }
-            .errback do
-              # TODO: no way to communicate the error in async mode
-              raise NotImplementedError
-            end
-        else
-          error = nil
-          # start EM, block until request is completed
-          EventMachine.run do
-            perform_single_request(env)
-              .callback { EventMachine.stop }
-              .errback do |client|
-                error = error_message(client)
-                EventMachine.stop
-              end
-          end
-          raise_error(error) if error
-        end
-      rescue EventMachine::Connectify::CONNECTError => e
-        if e.message.include?('Proxy Authentication Required')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required ")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      rescue StandardError => e
-        if defined?(::OpenSSL::SSL::SSLError) && \
-           e.is_a?(::OpenSSL::SSL::SSLError)
-          raise Faraday::SSLError, e
-        end
-
-        raise
-      end
-
-      # TODO: reuse the connection to support pipelining
-      def perform_single_request(env)
-        req = create_request(env)
-        req = req.setup_request(env[:method], request_config(env))
-        req.callback do |client|
-          if env[:request].stream_response?
-            warn "Streaming downloads for #{self.class.name} " \
-              'are not yet implemented.'
-            env[:request].on_data.call(
-              client.response,
-              client.response.bytesize
-            )
-          end
-          status = client.response_header.status
-          reason = client.response_header.http_reason
-          save_response(env, status, client.response, nil, reason) do |headers|
-            client.response_header.each do |name, value|
-              headers[name.to_sym] = value
-            end
-          end
-        end
-      end
-
-      def create_request(env)
-        EventMachine::HttpRequest.new(
-          env[:url], connection_config(env).merge(@connection_options)
-        )
-      end
-
-      def error_message(client)
-        client.error || 'request failed'
-      end
-
-      def raise_error(msg)
-        error_class = Faraday::ClientError
-        if timeout_message?(msg)
-          error_class = Faraday::TimeoutError
-          msg = 'request timed out'
-        elsif msg == Errno::ECONNREFUSED
-          error_class = Faraday::ConnectionFailed
-          msg = 'connection refused'
-        elsif msg == 'connection closed by server'
-          error_class = Faraday::ConnectionFailed
-        end
-        raise error_class, msg
-      end
-
-      def timeout_message?(msg)
-        msg == Errno::ETIMEDOUT ||
-          (msg.is_a?(String) && msg.include?('timeout error'))
-      end
-
-      # @return [Boolean]
-      def parallel?(env)
-        !!env[:parallel_manager]
-      end
-
-      # This parallel manager is designed to start an EventMachine loop
-      # and block until all registered requests have been completed.
-      class Manager
-        # @see reset
-        def initialize
-          reset
-        end
-
-        # Re-initializes instance variables
-        def reset
-          @registered_procs = []
-          @num_registered = 0
-          @num_succeeded = 0
-          @errors = []
-          @running = false
-        end
-
-        # @return [Boolean]
-        def running?
-          @running
-        end
-
-        def add(&block)
-          if running?
-            perform_request(&block)
-          else
-            @registered_procs << block
-          end
-          @num_registered += 1
-        end
-
-        def run
-          if @num_registered.positive?
-            @running = true
-            EventMachine.run do
-              @registered_procs.each do |proc|
-                perform_request(&proc)
-              end
-            end
-            unless @errors.empty?
-              raise Faraday::ClientError, @errors.first || 'connection failed'
-            end
-          end
-        ensure
-          reset
-        end
-
-        def perform_request
-          client = yield
-          client.callback do
-            @num_succeeded += 1
-            check_finished
-          end
-          client.errback do
-            @errors << client.error
-            check_finished
-          end
-        end
-
-        def check_finished
-          EventMachine.stop if @num_succeeded + @errors.size == @num_registered
-        end
-      end
-    end
-  end
-end

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'openssl'
-require 'em-http'
-
-# EventMachine patch to make SSL work.
-module EmHttpSslPatch
-  def ssl_verify_peer(cert_string)
-    begin
-      @last_seen_cert = OpenSSL::X509::Certificate.new(cert_string)
-    rescue OpenSSL::X509::CertificateError
-      return false
-    end
-
-    unless certificate_store.verify(@last_seen_cert)
-      raise OpenSSL::SSL::SSLError,
-            %(unable to verify the server certificate for "#{host}")
-    end
-
-    begin
-      certificate_store.add_cert(@last_seen_cert)
-    rescue OpenSSL::X509::StoreError => e
-      raise e unless e.message == 'cert already in hash table'
-    end
-    true
-  end
-
-  def ssl_handshake_completed
-    return true unless verify_peer?
-
-    unless verified_cert_identity?
-      raise OpenSSL::SSL::SSLError,
-            %(host "#{host}" does not match the server certificate)
-    end
-
-    true
-  end
-
-  def verify_peer?
-    parent.connopts.tls[:verify_peer]
-  end
-
-  def verified_cert_identity?
-    OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
-  end
-
-  def host
-    parent.uri.host
-  end
-
-  def certificate_store
-    @certificate_store ||= begin
-      store = OpenSSL::X509::Store.new
-      store.set_default_paths
-      ca_file = parent.connopts.tls[:cert_chain_file]
-      store.add_file(ca_file) if ca_file
-      store
-    end
-  end
-end
-
-EventMachine::HttpStubConnection.include(EmHttpSslPatch)

data/lib/faraday/adapter/em_synchrony.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-
-module Faraday
-  class Adapter
-    # EventMachine Synchrony adapter.
-    class EMSynchrony < Faraday::Adapter
-      include EMHttp::Options
-
-      dependency do
-        require 'em-synchrony/em-http'
-        require 'em-synchrony/em-multi'
-        require 'fiber'
-
-        require 'faraday/adapter/em_synchrony/parallel_manager'
-
-        if Faraday::Adapter::EMSynchrony.loaded?
-          begin
-            require 'openssl'
-          rescue LoadError
-            warn 'Warning: no such file to load -- openssl. ' \
-              'Make sure it is installed if you want HTTPS support'
-          else
-            require 'em-http/version'
-            if EventMachine::HttpRequest::VERSION < '1.1.6'
-              require 'faraday/adapter/em_http_ssl_patch'
-            end
-          end
-        end
-      end
-
-      self.supports_parallel = true
-
-      # @return [ParallelManager]
-      def self.setup_parallel_manager(_options = nil)
-        ParallelManager.new
-      end
-
-      def call(env)
-        super
-        request = create_request(env)
-
-        http_method = env[:method].to_s.downcase.to_sym
-
-        if env[:parallel_manager]
-          # Queue requests for parallel execution.
-          execute_parallel_request(env, request, http_method)
-        else
-          # Execute single request.
-          execute_single_request(env, request, http_method)
-        end
-
-        @app.call env
-      rescue Errno::ECONNREFUSED
-        raise Faraday::ConnectionFailed, $ERROR_INFO
-      rescue EventMachine::Connectify::CONNECTError => e
-        if e.message.include?('Proxy Authentication Required')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      rescue Errno::ETIMEDOUT => e
-        raise Faraday::TimeoutError, e
-      rescue RuntimeError => e
-        if e.message == 'connection closed by server'
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise Faraday::TimeoutError, e if e.message.include?('timeout error')
-
-        raise
-      rescue StandardError => e
-        if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
-          raise Faraday::SSLError, e
-        end
-
-        raise
-      end
-
-      def create_request(env)
-        EventMachine::HttpRequest.new(
-          Utils::URI(env[:url].to_s),
-          connection_config(env).merge(@connection_options)
-        )
-      end
-
-      private
-
-      def execute_parallel_request(env, request, http_method)
-        env[:parallel_manager].add(request, http_method,
-                                   request_config(env)) do |resp|
-          if (req = env[:request]).stream_response?
-            warn "Streaming downloads for #{self.class.name} " \
-                'are not yet implemented.'
-            req.on_data.call(resp.response, resp.response.bytesize)
-          end
-
-          save_response(env, resp.response_header.status,
-                        resp.response) do |resp_headers|
-            resp.response_header.each do |name, value|
-              resp_headers[name.to_sym] = value
-            end
-          end
-
-          # Finalize the response object with values from `env`.
-          env[:response].finish(env)
-        end
-      end
-
-      def execute_single_request(env, request, http_method)
-        block = -> { request.send(http_method, request_config(env)) }
-        client = call_block(block)
-
-        raise client.error if client&.error
-
-        if env[:request].stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-              'are not yet implemented.'
-          env[:request].on_data.call(
-            client.response,
-            client.response.bytesize
-          )
-        end
-        status = client.response_header.status
-        reason = client.response_header.http_reason
-        save_response(env, status, client.response, nil, reason) do |headers|
-          client.response_header.each do |name, value|
-            headers[name.to_sym] = value
-          end
-        end
-      end
-
-      def call_block(block)
-        client = nil
-
-        if EM.reactor_running?
-          client = block.call
-        else
-          EM.run do
-            Fiber.new do
-              client = block.call
-              EM.stop
-            end.resume
-          end
-        end
-
-        client
-      end
-    end
-  end
-end

data/lib/faraday/adapter/em_synchrony/parallel_manager.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    class EMSynchrony < Faraday::Adapter
-      # A parallel manager for EMSynchrony.
-      class ParallelManager
-        # Add requests to queue.
-        #
-        # @param request [EM::HttpRequest]
-        # @param method [Symbol, String] HTTP method
-        # @param args [Array] the rest of the positional arguments
-        def add(request, method, *args, &block)
-          queue << {
-            request: request,
-            method: method,
-            args: args,
-            block: block
-          }
-        end
-
-        # Run all requests on queue with `EM::Synchrony::Multi`, wrapping
-        # it in a reactor and fiber if needed.
-        def run
-          result = nil
-          if !EM.reactor_running?
-            EM.run do
-              Fiber.new do
-                result = perform
-                EM.stop
-              end.resume
-            end
-          else
-            result = perform
-          end
-          result
-        end
-
-        private
-
-        # The request queue.
-        def queue
-          @queue ||= []
-        end
-
-        # Main `EM::Synchrony::Multi` performer.
-        def perform
-          multi = ::EM::Synchrony::Multi.new
-
-          queue.each do |item|
-            method = "a#{item[:method]}".to_sym
-
-            req = item[:request].send(method, *item[:args])
-            req.callback(&item[:block])
-
-            req_name = "req_#{multi.requests.size}".to_sym
-            multi.add(req_name, req)
-          end
-
-          # Clear the queue, so parallel manager objects can be reused.
-          @queue = []
-
-          # Block fiber until all requests have returned.
-          multi.perform
-        end
-      end
-    end
-  end
-end

data/lib/faraday/adapter/excon.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Excon adapter.
-    class Excon < Faraday::Adapter
-      dependency 'excon'
-
-      def build_connection(env)
-        opts = opts_from_env(env)
-        ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
-      end
-
-      def call(env)
-        super
-
-        req_opts = {
-          method: env[:method].to_s.upcase,
-          headers: env[:request_headers],
-          body: read_body(env)
-        }
-
-        req = env[:request]
-        if req&.stream_response?
-          total = 0
-          req_opts[:response_block] = lambda do |chunk, _remain, _total|
-            req.on_data.call(chunk, total += chunk.size)
-          end
-        end
-
-        resp = connection(env) { |http| http.request(req_opts) }
-        save_response(env, resp.status.to_i, resp.body, resp.headers,
-                      resp.reason_phrase)
-
-        @app.call(env)
-      rescue ::Excon::Errors::SocketError => e
-        raise Faraday::TimeoutError, e if e.message.match?(/\btimeout\b/)
-
-        raise Faraday::SSLError, e if e.message.match?(/\bcertificate\b/)
-
-        raise Faraday::ConnectionFailed, e
-      rescue ::Excon::Errors::Timeout => e
-        raise Faraday::TimeoutError, e
-      end
-
-      # TODO: support streaming requests
-      def read_body(env)
-        env[:body].respond_to?(:read) ? env[:body].read : env[:body]
-      end
-
-      private
-
-      def opts_from_env(env)
-        opts = {}
-        amend_opts_with_ssl!(opts, env[:ssl]) if needs_ssl_settings?(env)
-
-        if (req = env[:request])
-          amend_opts_with_timeouts!(opts, req)
-          amend_opts_with_proxy_settings!(opts, req)
-        end
-
-        opts
-      end
-
-      def needs_ssl_settings?(env)
-        env[:url].scheme == 'https' && env[:ssl]
-      end
-
-      OPTS_KEYS = [
-        %i[client_cert client_cert],
-        %i[client_key client_key],
-        %i[certificate certificate],
-        %i[private_key private_key],
-        %i[ssl_ca_path ca_path],
-        %i[ssl_ca_file ca_file],
-        %i[ssl_version version],
-        %i[ssl_min_version min_version],
-        %i[ssl_max_version max_version]
-      ].freeze
-
-      def amend_opts_with_ssl!(opts, ssl)
-        opts[:ssl_verify_peer] = !!ssl.fetch(:verify, true)
-        # https://github.com/geemus/excon/issues/106
-        # https://github.com/jruby/jruby-ossl/issues/19
-        opts[:nonblock] = false
-
-        OPTS_KEYS.each do |(key_in_opts, key_in_ssl)|
-          next unless ssl[key_in_ssl]
-
-          opts[key_in_opts] = ssl[key_in_ssl]
-        end
-      end
-
-      def amend_opts_with_timeouts!(opts, req)
-        if (sec = request_timeout(:read, req))
-          opts[:read_timeout] = sec
-        end
-
-        if (sec = request_timeout(:write, req))
-          opts[:write_timeout] = sec
-        end
-
-        return unless (sec = request_timeout(:open, req))
-
-        opts[:connect_timeout] = sec
-      end
-
-      def amend_opts_with_proxy_settings!(opts, req)
-        opts[:proxy] = proxy_settings_for_opts(req[:proxy]) if req[:proxy]
-      end
-
-      def proxy_settings_for_opts(proxy)
-        {
-          host: proxy[:uri].host,
-          hostname: proxy[:uri].hostname,
-          port: proxy[:uri].port,
-          scheme: proxy[:uri].scheme,
-          user: proxy[:user],
-          password: proxy[:password]
-        }
-      end
-    end
-  end
-end

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Net::HTTP::Persistent adapter.
-    class NetHttpPersistent < NetHttp
-      dependency 'net/http/persistent'
-
-      private
-
-      def net_http_connection(env)
-        @cached_connection ||=
-          if Net::HTTP::Persistent.instance_method(:initialize)
-                                  .parameters.first == %i[key name]
-            options = { name: 'Faraday' }
-            if @connection_options.key?(:pool_size)
-              options[:pool_size] = @connection_options[:pool_size]
-            end
-            Net::HTTP::Persistent.new(**options)
-          else
-            Net::HTTP::Persistent.new('Faraday')
-          end
-
-        proxy_uri = proxy_uri(env)
-        if @cached_connection.proxy_uri != proxy_uri
-          @cached_connection.proxy = proxy_uri
-        end
-        @cached_connection
-      end
-
-      def proxy_uri(env)
-        proxy_uri = nil
-        if (proxy = env[:request][:proxy])
-          proxy_uri = if proxy[:uri].is_a?(::URI::HTTP)
-                        proxy[:uri].dup
-                      else
-                        ::URI.parse(proxy[:uri].to_s)
-                      end
-          proxy_uri.user = proxy_uri.password = nil
-          # awful patch for net-http-persistent 2.8
-          # not unescaping user/password
-          if proxy[:user]
-            (class << proxy_uri; self; end).class_eval do
-              define_method(:user) { proxy[:user] }
-              define_method(:password) { proxy[:password] }
-            end
-          end
-        end
-        proxy_uri
-      end
-
-      def perform_request(http, env)
-        http.request env[:url], create_request(env)
-      rescue Errno::ETIMEDOUT, Net::OpenTimeout => e
-        raise Faraday::TimeoutError, e
-      rescue Net::HTTP::Persistent::Error => e
-        raise Faraday::TimeoutError, e if e.message.include? 'Timeout'
-
-        if e.message.include? 'connection refused'
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise
-      end
-
-      SSL_CONFIGURATIONS = {
-        certificate: :client_cert,
-        private_key: :client_key,
-        ca_file: :ca_file,
-        ssl_version: :version,
-        min_version: :min_version,
-        max_version: :max_version
-      }.freeze
-
-      def configure_ssl(http, ssl)
-        return unless ssl
-
-        http_set(http, :verify_mode, ssl_verify_mode(ssl))
-        http_set(http, :cert_store, ssl_cert_store(ssl))
-
-        SSL_CONFIGURATIONS
-          .select { |_, key| ssl[key] }
-          .each { |target, key| http_set(http, target, ssl[key]) }
-      end
-
-      def http_set(http, attr, value)
-        http.send("#{attr}=", value) if http.send(attr) != value
-      end
-    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