faraday 0.17.3 → 1.2.0

data/lib/faraday/adapter.rb

@@ -1,43 +1,76 @@
+# frozen_string_literal: true
+
 module Faraday
-  # Public: This is a base class for all Faraday adapters.  Adapters are
+  # Base class for all Faraday adapters. Adapters are
   # responsible for fulfilling a Faraday request.
-  class Adapter < Middleware
-    CONTENT_LENGTH = 'Content-Length'.freeze
-
-    register_middleware File.expand_path('../adapter', __FILE__),
-      :test => [:Test, 'test'],
-      :net_http => [:NetHttp, 'net_http'],
-      :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']
-
-    # Public: This module marks an Adapter as supporting parallel requests.
+  class Adapter
+    extend MiddlewareRegistry
+    extend DependencyLoader
+
+    CONTENT_LENGTH = 'Content-Length'
+
+    register_middleware File.expand_path('adapter', __dir__),
+                        test: [:Test, 'test'],
+                        net_http: [:NetHttp, 'net_http'],
+                        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']
+
+    # This module marks an Adapter as supporting parallel requests.
     module Parallelism
       attr_writer :supports_parallel
-      def supports_parallel?() @supports_parallel end
+
+      def supports_parallel?
+        @supports_parallel
+      end
 
       def inherited(subclass)
         super
-        subclass.supports_parallel = self.supports_parallel?
+        subclass.supports_parallel = supports_parallel?
       end
     end
 
     extend Parallelism
     self.supports_parallel = false
 
-    def initialize(app = nil, opts = {}, &block)
-      super(app)
+    def initialize(_app = nil, opts = {}, &block)
+      @app = ->(env) { env.response }
       @connection_options = opts
       @config_block = block
     end
 
+    # Yields or returns an adapter's configured connection. Depends on
+    # #build_connection being defined on this adapter.
+    #
+    # @param env [Faraday::Env, Hash] The env object for a faraday request.
+    #
+    # @return The return value of the given block, or the HTTP connection object
+    #         if no block is given.
+    def connection(env)
+      conn = build_connection(env)
+      return conn unless block_given?
+
+      yield conn
+    end
+
+    # Close any persistent connections. The adapter should still be usable
+    # after calling close.
+    def close
+      # Possible implementation:
+      #   @app.close if @app.respond_to?(:close)
+    end
+
     def call(env)
       env.clear_body if env.needs_body?
+      env.response = Response.new
     end
 
     private
@@ -45,11 +78,39 @@ module Faraday
     def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body
-      env.reason_phrase = reason_phrase && reason_phrase.to_s.strip
+      env.reason_phrase = reason_phrase&.to_s&.strip
       env.response_headers = Utils::Headers.new.tap do |response_headers|
         response_headers.update headers unless headers.nil?
         yield(response_headers) if block_given?
       end
+
+      env.response.finish(env) unless env.parallel?
+      env.response
+    end
+
+    # Fetches either a read, write, or open timeout setting. Defaults to the
+    # :timeout value if a more specific one is not given.
+    #
+    # @param type [Symbol] Describes which timeout setting to get: :read,
+    #                      :write, or :open.
+    # @param options [Hash] Hash containing Symbol keys like :timeout,
+    #                       :read_timeout, :write_timeout, :open_timeout, or
+    #                       :timeout
+    #
+    # @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
+    #                        has been set.
+    def request_timeout(type, options)
+      key = TIMEOUT_KEYS.fetch(type) do
+        msg = "Expected :read, :write, :open. Got #{type.inspect} :("
+        raise ArgumentError, msg
+      end
+      options[key] || options[:timeout]
     end
+
+    TIMEOUT_KEYS = {
+      read: :read_timeout,
+      open: :open_timeout,
+      write: :write_timeout
+    }.freeze
   end
 end

data/lib/faraday/adapter/em_http.rb

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 module Faraday
   class Adapter
-    # EventMachine adapter is useful for either asynchronous requests
-    # when in EM reactor loop or for making parallel requests in
+    # 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)
@@ -16,10 +21,10 @@ module Faraday
 
         def request_config(env)
           options = {
-            :body => read_body(env),
-            :head => env[:request_headers],
-            # :keepalive => true,
-            # :file => 'path/to/file', # stream data off disk
+            body: read_body(env),
+            head: env[:request_headers]
+            # keepalive: true,
+            # file: 'path/to/file', # stream data off disk
           }
           configure_compression(options, env)
           options
@@ -30,44 +35,52 @@ module Faraday
           body.respond_to?(:read) ? body.read : body
         end
 
+        # Reads out proxy settings from env into options
         def configure_proxy(options, env)
-          if proxy = request_options(env)[:proxy]
-            options[:proxy] = {
-              :host => proxy[:uri].host,
-              :port => proxy[:uri].port,
-              :authorization => [proxy[:user], proxy[:password]]
-            }
-          end
+          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)
-          if bind = request_options(env)[:bind]
-            options[:bind] = {
-              :host => bind[:host],
-              :port => bind[:port]
-            }
-          end
+          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)
-          if env[:url].scheme == 'https' && env[:ssl]
-            options[:ssl] = {
-              :cert_chain_file => env[:ssl][:ca_file],
-              :verify_peer => env[:ssl].fetch(:verify, true)
-            }
-          end
+          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)
-          timeout, open_timeout = request_options(env).values_at(:timeout, :open_timeout)
-          options[:connect_timeout] = options[:inactivity_timeout] = timeout
-          options[:connect_timeout] = open_timeout if open_timeout
+          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)
-          if env[:method] == :get and not options[:head].key? 'accept-encoding'
-            options[:head]['accept-encoding'] = 'gzip, compressed'
-          end
+          return unless (env[:method] == :get) &&
+                        !options[:head].key?('accept-encoding')
+
+          options[:head]['accept-encoding'] = 'gzip, compressed'
         end
 
         def request_options(env)
@@ -77,11 +90,26 @@ module Faraday
 
       include Options
 
-      dependency 'em-http'
+      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
 
-      def self.setup_parallel_manager(options = nil)
+      # @return [Manager]
+      def self.setup_parallel_manager(_options = nil)
         Manager.new
       end
 
@@ -94,95 +122,114 @@ module Faraday
       def perform_request(env)
         if parallel?(env)
           manager = env[:parallel_manager]
-          manager.add {
-            perform_single_request(env).
-              callback { env[:response].finish(env) }
-          }
-        else
-          unless EventMachine.reactor_running?
-            error = nil
-            # start EM, block until request is completed
-            EventMachine.run do
-              perform_single_request(env).
-                callback { EventMachine.stop }.
-                errback { |client|
-                  error = error_message(client)
-                  EventMachine.stop
-                }
+          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
-            raise_error(error) if error
-          else
-            # 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 {
-                # TODO: no way to communicate the error in async mode
-                raise NotImplementedError
-              }
+        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 => err
-        if err.message.include?("Proxy Authentication Required")
-          raise Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Faraday::ConnectionFailed, err
+      rescue EventMachine::Connectify::CONNECTError => e
+        if e.message.include?('Proxy Authentication Required')
+          raise Faraday::ConnectionFailed,
+                %(407 "Proxy Authentication Required ")
         end
-      rescue => err
-        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-          raise Faraday::SSLError, err
-        else
-          raise
+
+        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.setup_request(env[:method], request_config(env)).callback { |client|
+        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 |resp_headers|
+          save_response(env, status, client.response, nil, reason) do |headers|
             client.response_header.each do |name, value|
-              resp_headers[name.to_sym] = 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))
+        EventMachine::HttpRequest.new(
+          env[:url], connection_config(env).merge(@connection_options)
+        )
       end
 
       def error_message(client)
-        client.error or "request failed"
+        client.error || 'request failed'
       end
 
       def raise_error(msg)
-        errklass = Faraday::ClientError
-        if msg == Errno::ETIMEDOUT
-          errklass = Faraday::TimeoutError
-          msg = "request timed out"
+        error_class = Faraday::ClientError
+        if timeout_message?(msg)
+          error_class = Faraday::TimeoutError
+          msg = 'request timed out'
         elsif msg == Errno::ECONNREFUSED
-          errklass = Faraday::ConnectionFailed
-          msg = "connection refused"
-        elsif msg == "connection closed by server"
-          errklass = Faraday::ConnectionFailed
+          error_class = Faraday::ConnectionFailed
+          msg = 'connection refused'
+        elsif msg == 'connection closed by server'
+          error_class = Faraday::ConnectionFailed
         end
-        raise errklass, msg
+        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
 
-      # The parallel manager is designed to start an EventMachine loop
+      # 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
@@ -191,11 +238,14 @@ module Faraday
           @running = false
         end
 
-        def running?() @running end
+        # @return [Boolean]
+        def running?
+          @running
+        end
 
         def add(&block)
           if running?
-            perform_request { yield }
+            perform_request(&block)
           else
             @registered_procs << block
           end
@@ -203,15 +253,15 @@ module Faraday
         end
 
         def run
-          if @num_registered > 0
+          if @num_registered.positive?
             @running = true
             EventMachine.run do
               @registered_procs.each do |proc|
                 perform_request(&proc)
               end
             end
-            if @errors.size > 0
-              raise Faraday::ClientError, @errors.first || "connection failed"
+            unless @errors.empty?
+              raise Faraday::ClientError, @errors.first || 'connection failed'
             end
           end
         ensure
@@ -220,24 +270,20 @@ module Faraday
 
         def perform_request
           client = yield
-          client.callback { @num_succeeded += 1; check_finished }
-          client.errback { @errors << client.error; check_finished }
+          client.callback do
+            @num_succeeded += 1
+            check_finished
+          end
+          client.errback do
+            @errors << client.error
+            check_finished
+          end
         end
 
         def check_finished
-          if @num_succeeded + @errors.size == @num_registered
-            EventMachine.stop
-          end
+          EventMachine.stop if @num_succeeded + @errors.size == @num_registered
         end
       end
     end
   end
 end
-
-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 'faraday/adapter/em_http_ssl_patch'
-end if Faraday::Adapter::EMHttp.loaded?