faraday 0.17.6 → 1.0.0.pre.rc1

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,53 @@ 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)
+          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
         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)
@@ -81,7 +95,8 @@ module Faraday
 
       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 +109,113 @@ 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) && 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,27 +224,30 @@ module Faraday
           @running = false
         end
 
-        def running?() @running end
+        # @return [Boolean]
+        def running?
+          @running
+        end
 
-        def add(&block)
+        def add
           if running?
             perform_request { yield }
           else
-            @registered_procs << block
+            @registered_procs << Proc.new
           end
           @num_registered += 1
         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 +256,31 @@ 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?
+if Faraday::Adapter::EMHttp.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 'faraday/adapter/em_http_ssl_patch'
+  end
+end

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -1,43 +1,49 @@
+# frozen_string_literal: true
+
 require 'openssl'
 require 'em-http'
 
+# EventMachine patch to make SSL work.
 module EmHttpSslPatch
   def ssl_verify_peer(cert_string)
-    cert = nil
     begin
-      cert = OpenSSL::X509::Certificate.new(cert_string)
+      @last_seen_cert = OpenSSL::X509::Certificate.new(cert_string)
     rescue OpenSSL::X509::CertificateError
       return false
     end
 
-    @last_seen_cert = cert
-
-    if certificate_store.verify(@last_seen_cert)
-      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
-    else
-      raise OpenSSL::SSL::SSLError.new(%(unable to verify the server certificate for "#{host}"))
+    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 OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
-      raise OpenSSL::SSL::SSLError.new(%(host "#{host}" does not match the server certificate))
-    else
-      true
+    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

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

@@ -1,16 +1,21 @@
+# frozen_string_literal: true
+
 module Faraday
   class Adapter
     class EMSynchrony < Faraday::Adapter
+      # A parallel manager for EMSynchrony.
       class ParallelManager
-
-        # Add requests to queue. The `request` argument should be a
-        # `EM::HttpRequest` object.
+        # 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
+            request: request,
+            method: method,
+            args: args,
+            block: block
           }
         end
 
@@ -19,19 +24,18 @@ module Faraday
         def run
           result = nil
           if !EM.reactor_running?
-            EM.run {
+            EM.run do
               Fiber.new do
                 result = perform
                 EM.stop
               end.resume
-            }
+            end
           else
             result = perform
           end
           result
         end
 
-
         private
 
         # The request queue.
@@ -59,8 +63,7 @@ module Faraday
           # Block fiber until all requests have returned.
           multi.perform
         end
-
-      end # ParallelManager
-    end # EMSynchrony
-  end # Adapter
-end # Faraday
+      end
+    end
+  end
+end