faraday 1.3.1 → 1.5.0

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/lib/faraday/adapter/patron.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  class Adapter
-    # Patron adapter.
-    class Patron < Faraday::Adapter
-      dependency 'patron'
-
-      def build_connection(env)
-        session = ::Patron::Session.new
-        @config_block&.call(session)
-        if (env[:url].scheme == 'https') && env[:ssl]
-          configure_ssl(session, env[:ssl])
-        end
-
-        if (req = env[:request])
-          configure_timeouts(session, req)
-          configure_proxy(session, req[:proxy])
-        end
-
-        session
-      end
-
-      def call(env)
-        super
-        # TODO: support streaming requests
-        env[:body] = env[:body].read if env[:body].respond_to? :read
-
-        response = connection(env) do |session|
-          begin
-            data = env[:body] ? env[:body].to_s : nil
-            session.request(env[:method], env[:url].to_s,
-                            env[:request_headers], data: data)
-          rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
-            raise Faraday::ConnectionFailed, $ERROR_INFO
-          end
-        end
-
-        if (req = env[:request]).stream_response?
-          warn "Streaming downloads for #{self.class.name} " \
-            'are not yet implemented.'
-          req.on_data.call(response.body, response.body.bytesize)
-        end
-        # Remove the "HTTP/1.1 200", leaving just the reason phrase
-        reason_phrase = response.status_line.gsub(/^.* \d{3} /, '')
-
-        save_response(env, response.status, response.body,
-                      response.headers, reason_phrase)
-
-        @app.call env
-      rescue ::Patron::TimeoutError => e
-        if connection_timed_out_message?(e.message)
-          raise Faraday::ConnectionFailed, e
-        end
-
-        raise Faraday::TimeoutError, e
-      rescue ::Patron::Error => e
-        if e.message.include?('code 407')
-          raise Faraday::ConnectionFailed,
-                %(407 "Proxy Authentication Required ")
-        end
-
-        raise Faraday::ConnectionFailed, e
-      end
-
-      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
-        # HAX: helps but doesn't work completely
-        # https://github.com/toland/patron/issues/34
-        ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          if actions[0].is_a?(Symbol)
-            actions << :patch unless actions.include? :patch
-            actions << :options unless actions.include? :options
-          else
-            # Patron 0.4.20 and up
-            actions << 'PATCH' unless actions.include? 'PATCH'
-            actions << 'OPTIONS' unless actions.include? 'OPTIONS'
-          end
-        end
-      end
-
-      def configure_ssl(session, ssl)
-        if ssl.fetch(:verify, true)
-          session.cacert = ssl[:ca_file]
-        else
-          session.insecure = true
-        end
-      end
-
-      def configure_timeouts(session, req)
-        return unless req
-
-        if (sec = request_timeout(:read, req))
-          session.timeout = sec
-        end
-
-        return unless (sec = request_timeout(:open, req))
-
-        session.connect_timeout = sec
-      end
-
-      def configure_proxy(session, proxy)
-        return unless proxy
-
-        proxy_uri = proxy[:uri].dup
-        proxy_uri.user = proxy[:user] &&
-                         Utils.escape(proxy[:user]).gsub('+', '%20')
-        proxy_uri.password = proxy[:password] &&
-                             Utils.escape(proxy[:password]).gsub('+', '%20')
-        session.proxy = proxy_uri.to_s
-      end
-
-      private
-
-      CURL_TIMEOUT_MESSAGES = [
-        'Connection time-out',
-        'Connection timed out',
-        'Timed out before name resolve',
-        'server connect has timed out',
-        'Resolving timed out',
-        'name lookup timed out',
-        'timed out before SSL',
-        'connect() timed out'
-      ].freeze
-
-      def connection_timed_out_message?(message)
-        CURL_TIMEOUT_MESSAGES.any? do |curl_message|
-          message.include?(curl_message)
-        end
-      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