faraday 0.16.0 → 0.17.0

data/lib/faraday/adapter/em_http.rb

@@ -1,15 +1,10 @@
-# 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
+    # EventMachine adapter is useful for either asynchronous requests
+    # when in 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)
@@ -21,10 +16,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
@@ -35,53 +30,44 @@ module Faraday
           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]]
-          }
+          if proxy = request_options(env)[:proxy]
+            options[:proxy] = {
+              :host => proxy[:uri].host,
+              :port => proxy[:uri].port,
+              :authorization => [proxy[:user], proxy[:password]]
+            }
+          end
         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]
-          }
+          if bind = request_options(env)[:bind]
+            options[:bind] = {
+              :host => bind[:host],
+              :port => bind[:port]
+            }
+          end
         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)
-          }
+          if env[:url].scheme == 'https' && env[:ssl]
+            options[:ssl] = {
+              :cert_chain_file => env[:ssl][:ca_file],
+              :verify_peer => env[:ssl].fetch(:verify, true)
+            }
+          end
         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)
-          return unless (env[:method] == :get) &&
-                        !options[:head].key?('accept-encoding')
-
-          options[:head]['accept-encoding'] = 'gzip, compressed'
+          if env[:method] == :get and not options[:head].key? 'accept-encoding'
+            options[:head]['accept-encoding'] = 'gzip, compressed'
+          end
         end
 
         def request_options(env)
@@ -95,8 +81,7 @@ module Faraday
 
       self.supports_parallel = true
 
-      # @return [Manager]
-      def self.setup_parallel_manager(_options = nil)
+      def self.setup_parallel_manager(options = nil)
         Manager.new
       end
 
@@ -109,113 +94,95 @@ module Faraday
       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
+          manager.add {
+            perform_single_request(env).
+              callback { env[:response].finish(env) }
+          }
         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
+          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
+                }
+            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
+              }
           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 ")
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
         end
-
-        raise Faraday::ConnectionFailed, e
-      rescue StandardError => e
-        if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
-          raise Faraday::SSLError, e
+      rescue => err
+        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+          raise Faraday::SSLError, err
+        else
+          raise
         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
+        req.setup_request(env[:method], request_config(env)).callback { |client|
           status = client.response_header.status
           reason = client.response_header.http_reason
-          save_response(env, status, client.response, nil, reason) do |headers|
+          save_response(env, status, client.response, nil, reason) do |resp_headers|
             client.response_header.each do |name, value|
-              headers[name.to_sym] = value
+              resp_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 || 'request failed'
+        client.error or "request failed"
       end
 
       def raise_error(msg)
-        error_class = Faraday::ClientError
-        if timeout_message?(msg)
-          error_class = Faraday::TimeoutError
-          msg = 'request timed out'
+        errklass = Faraday::Error::ClientError
+        if msg == Errno::ETIMEDOUT
+          errklass = Faraday::Error::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
+          errklass = Faraday::Error::ConnectionFailed
+          msg = "connection refused"
+        elsif msg == "connection closed by server"
+          errklass = Faraday::Error::ConnectionFailed
         end
-        raise error_class, msg
+        raise errklass, 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
+      # The 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
@@ -224,30 +191,27 @@ module Faraday
           @running = false
         end
 
-        # @return [Boolean]
-        def running?
-          @running
-        end
+        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.positive?
+          if @num_registered > 0
             @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'
+            if @errors.size > 0
+              raise Faraday::Error::ClientError, @errors.first || "connection failed"
             end
           end
         ensure
@@ -256,31 +220,24 @@ module Faraday
 
         def perform_request
           client = yield
-          client.callback do
-            @num_succeeded += 1
-            check_finished
-          end
-          client.errback do
-            @errors << client.error
-            check_finished
-          end
+          client.callback { @num_succeeded += 1; check_finished }
+          client.errback { @errors << client.error; check_finished }
         end
 
         def check_finished
-          EventMachine.stop if @num_succeeded + @errors.size == @num_registered
+          if @num_succeeded + @errors.size == @num_registered
+            EventMachine.stop
+          end
         end
       end
     end
   end
 end
 
-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
+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?

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -1,49 +1,43 @@
-# 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
-      @last_seen_cert = OpenSSL::X509::Certificate.new(cert_string)
+      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'
+    @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}"))
     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)
+    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
     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,21 +1,16 @@
-# 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
+
+        # Add requests to queue. The `request` argument should be a
+        # `EM::HttpRequest` object.
         def add(request, method, *args, &block)
           queue << {
-            request: request,
-            method: method,
-            args: args,
-            block: block
+            :request => request,
+            :method => method,
+            :args => args,
+            :block => block
           }
         end
 
@@ -24,18 +19,19 @@ module Faraday
         def run
           result = nil
           if !EM.reactor_running?
-            EM.run do
+            EM.run {
               Fiber.new do
                 result = perform
                 EM.stop
               end.resume
-            end
+            }
           else
             result = perform
           end
           result
         end
 
+
         private
 
         # The request queue.
@@ -63,7 +59,8 @@ module Faraday
           # Block fiber until all requests have returned.
           multi.perform
         end
-      end
-    end
-  end
-end
+
+      end # ParallelManager
+    end # EMSynchrony
+  end # Adapter
+end # Faraday