faraday 0.16.1 → 0.17.4

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :test
+
+desc "Run all tests"
+task :test => :spec do
+  exec 'script/test'
+end

data/lib/faraday.rb

@@ -1,153 +1,128 @@
-# frozen_string_literal: true
-
+require 'thread'
 require 'cgi'
 require 'set'
 require 'forwardable'
-require 'faraday/middleware_registry'
-require 'faraday/dependency_loader'
 
-# This is the main namespace for Faraday.
+# Public: This is the main namespace for Faraday.  You can either use it to
+# create Faraday::Connection objects, or access it directly.
 #
-# It provides methods to create {Connection} objects, and HTTP-related
-# methods to use directly.
+# Examples
 #
-# @example Helpful class methods for easy usage
 #   Faraday.get "http://faraday.com"
 #
-# @example Helpful class method `.new` to create {Connection} objects.
 #   conn = Faraday.new "http://faraday.com"
 #   conn.get '/'
 #
 module Faraday
-  VERSION = '0.16.1'
-  METHODS_WITH_QUERY = %w[get head delete connect trace].freeze
-  METHODS_WITH_BODY = %w[post put patch].freeze
+  VERSION = "0.17.4"
 
   class << self
-    # The root path that Faraday is being loaded from.
-    #
-    # This is the root from where the libraries are auto-loaded.
-    #
-    # @return [String]
+    # Public: Gets or sets the root path that Faraday is being loaded from.
+    # This is the root from where the libraries are auto-loaded from.
     attr_accessor :root_path
 
-    # Gets or sets the path that the Faraday libs are loaded from.
-    # @return [String]
+    # Public: Gets or sets the path that the Faraday libs are loaded from.
     attr_accessor :lib_path
 
-    # @overload default_adapter
-    #   Gets the Symbol key identifying a default Adapter to use
-    #   for the default {Faraday::Connection}. Defaults to `:net_http`.
-    #   @return [Symbol] the default adapter
-    # @overload default_adapter=(adapter)
-    #   Updates default adapter while resetting {.default_connection}.
-    #   @return [Symbol] the new default_adapter.
+    # Public: Gets or sets the Symbol key identifying a default Adapter to use
+    # for the default Faraday::Connection.
     attr_reader :default_adapter
 
-    # Documented below, see default_connection
+    # Public: Sets the default Faraday::Connection for simple scripts that
+    # access the Faraday constant directly.
+    #
+    #     Faraday.get "https://faraday.com"
     attr_writer :default_connection
 
-    # Tells Faraday to ignore the environment proxy (http_proxy).
-    # Defaults to `false`.
-    # @return [Boolean]
+    # Public: Tells faraday to ignore the environment proxy (http_proxy).
     attr_accessor :ignore_env_proxy
 
-    # Initializes a new {Connection}.
-    #
-    # @param url [String,Hash] The optional String base URL to use as a prefix
-    #           for all requests.  Can also be the options Hash. Any of these
-    #           values will be set on every request made, unless overridden
-    #           for a specific request.
-    # @param options [Hash]
-    # @option options [String] :url Base URL
-    # @option options [Hash] :params Hash of unencoded URI query params.
-    # @option options [Hash] :headers Hash of unencoded HTTP headers.
-    # @option options [Hash] :request Hash of request options.
-    # @option options [Hash] :ssl Hash of SSL options.
-    # @option options [Hash] :proxy Hash of Proxy options.
-    # @return [Faraday::Connection]
-    #
-    # @example With an URL argument
+    # Public: Initializes a new Faraday::Connection.
+    #
+    # url     - The optional String base URL to use as a prefix for all
+    #           requests.  Can also be the options Hash.
+    # options - The optional Hash used to configure this Faraday::Connection.
+    #           Any of these values will be set on every request made, unless
+    #           overridden for a specific request.
+    #           :url     - String base URL.
+    #           :params  - Hash of URI query unencoded key/value pairs.
+    #           :headers - Hash of unencoded HTTP header key/value pairs.
+    #           :request - Hash of request options.
+    #           :ssl     - Hash of SSL options.
+    #           :proxy   - Hash of Proxy options.
+    #
+    # Examples
+    #
     #   Faraday.new 'http://faraday.com'
-    #   # => Faraday::Connection to http://faraday.com
-    #
-    # @example With an URL argument and an options hash
-    #   Faraday.new 'http://faraday.com', params: { page: 1 }
-    #   # => Faraday::Connection to http://faraday.com?page=1
-    #
-    # @example With everything in an options hash
-    #   Faraday.new url: 'http://faraday.com',
-    #               params: { page: 1 }
-    #   # => Faraday::Connection to http://faraday.com?page=1
-    def new(url = nil, options = {}, &block)
-      options = default_connection_options.merge(options)
+    #
+    #   # http://faraday.com?page=1
+    #   Faraday.new 'http://faraday.com', :params => {:page => 1}
+    #
+    #   # same
+    #
+    #   Faraday.new :url => 'http://faraday.com',
+    #     :params => {:page => 1}
+    #
+    # Returns a Faraday::Connection.
+    def new(url = nil, options = nil, &block)
+      options = options ? default_connection_options.merge(options) : default_connection_options
       Faraday::Connection.new(url, options, &block)
     end
 
-    # @private
     # Internal: Requires internal Faraday libraries.
     #
-    # @param libs [Array] one or more relative String names to Faraday classes.
-    # @return [void]
+    # *libs - One or more relative String names to Faraday classes.
+    #
+    # Returns nothing.
     def require_libs(*libs)
       libs.each do |lib|
         require "#{lib_path}/#{lib}"
       end
     end
 
-    alias require_lib require_libs
-
-    # Documented elsewhere, see default_adapter reader
+    # Public: Updates default adapter while resetting
+    # #default_connection.
+    #
+    # Returns the new default_adapter.
     def default_adapter=(adapter)
       @default_connection = nil
       @default_adapter = adapter
     end
 
-    def respond_to_missing?(symbol, include_private = false)
+    alias require_lib require_libs
+
+    def respond_to?(symbol, include_private = false)
       default_connection.respond_to?(symbol, include_private) || super
     end
 
-    private
-
+  private
     # Internal: Proxies method calls on the Faraday constant to
-    # .default_connection.
+    # #default_connection.
     def method_missing(name, *args, &block)
-      if default_connection.respond_to?(name)
-        default_connection.send(name, *args, &block)
-      else
-        super
-      end
+      default_connection.send(name, *args, &block)
     end
   end
 
   self.ignore_env_proxy = false
-  self.root_path = File.expand_path __dir__
-  self.lib_path = File.expand_path 'faraday', __dir__
+  self.root_path = File.expand_path "..", __FILE__
+  self.lib_path = File.expand_path "../faraday", __FILE__
   self.default_adapter = :net_http
 
-  # @overload default_connection
-  #   Gets the default connection used for simple scripts.
-  #   @return [Faraday::Connection] a connection configured with
-  #   the default_adapter.
-  # @overload default_connection=(connection)
-  #   @param connection [Faraday::Connection]
-  #   Sets the default {Faraday::Connection} for simple scripts that
-  #   access the Faraday constant directly, such as
-  #   <code>Faraday.get "https://faraday.com"</code>.
+  # Gets the default connection used for simple scripts.
+  #
+  # Returns a Faraday::Connection, configured with the #default_adapter.
   def self.default_connection
     @default_connection ||= Connection.new(default_connection_options)
   end
 
-  # Gets the default connection options used when calling {Faraday#new}.
+  # Gets the default connection options used when calling Faraday#new.
   #
-  # @return [Faraday::ConnectionOptions]
+  # Returns a Faraday::ConnectionOptions.
   def self.default_connection_options
     @default_connection_options ||= ConnectionOptions.new
   end
 
-  # Sets the default options used when calling {Faraday#new}.
-  #
-  # @param options [Hash, Faraday::ConnectionOptions]
+  # Public: Sets the default options used when calling Faraday#new.
   def self.default_connection_options=(options)
     @default_connection = nil
     @default_connection_options = ConnectionOptions.from(options)
@@ -158,9 +133,115 @@ module Faraday
     Timer = Timeout
   end
 
-  require_libs 'utils', 'options', 'connection', 'rack_builder', 'parameters',
-               'middleware', 'adapter', 'request', 'response', 'error',
-               'file_part', 'param_part'
+  # Public: Adds the ability for other modules to register and lookup
+  # middleware classes.
+  module MiddlewareRegistry
+    # Public: Register middleware class(es) on the current module.
+    #
+    # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
+    #           as fully qualified constant, or a Proc that will be lazily
+    #           called to return the former.
+    #
+    # Examples
+    #
+    #   module Faraday
+    #     class Whatever
+    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
+    #       register_middleware :foo => Foo
+    #
+    #       # Middleware looked up by :bar returns Faraday::Whatever.const_get(:Bar)
+    #       register_middleware :bar => :Bar
+    #
+    #       # Middleware looked up by :baz requires 'baz' and returns Faraday::Whatever.const_get(:Baz)
+    #       register_middleware :baz => [:Baz, 'baz']
+    #     end
+    #   end
+    #
+    # Returns nothing.
+    def register_middleware(autoload_path = nil, mapping = nil)
+      if mapping.nil?
+        mapping = autoload_path
+        autoload_path = nil
+      end
+      middleware_mutex do
+        @middleware_autoload_path = autoload_path if autoload_path
+        (@registered_middleware ||= {}).update(mapping)
+      end
+    end
 
-  require_lib 'autoload' unless ENV['FARADAY_NO_AUTOLOAD']
+    # Public: Lookup middleware class with a registered Symbol shortcut.
+    #
+    # key - The Symbol key for the registered middleware.
+    #
+    # Examples
+    #
+    #   module Faraday
+    #     class Whatever
+    #       register_middleware :foo => Foo
+    #     end
+    #   end
+    #
+    #   Faraday::Whatever.lookup_middleware(:foo)
+    #   # => Faraday::Whatever::Foo
+    #
+    # Returns a middleware Class.
+    def lookup_middleware(key)
+      load_middleware(key) ||
+        raise(Faraday::Error.new("#{key.inspect} is not registered on #{self}"))
+    end
+
+    def middleware_mutex(&block)
+      @middleware_mutex ||= begin
+        require 'monitor'
+        Monitor.new
+      end
+      @middleware_mutex.synchronize(&block)
+    end
+
+    def fetch_middleware(key)
+      defined?(@registered_middleware) && @registered_middleware[key]
+    end
+
+    def load_middleware(key)
+      value = fetch_middleware(key)
+      case value
+      when Module
+        value
+      when Symbol, String
+        middleware_mutex do
+          @registered_middleware[key] = const_get(value)
+        end
+      when Proc
+        middleware_mutex do
+          @registered_middleware[key] = value.call
+        end
+      when Array
+        middleware_mutex do
+          const, path = value
+          if root = @middleware_autoload_path
+            path = "#{root}/#{path}"
+          end
+          require(path)
+          @registered_middleware[key] = const
+        end
+        load_middleware(key)
+      end
+    end
+  end
+
+  def self.const_missing(name)
+    if name.to_sym == :Builder
+      warn "Faraday::Builder is now Faraday::RackBuilder."
+      const_set name, RackBuilder
+    else
+      super
+    end
+  end
+
+  require_libs "utils", "options", "connection", "rack_builder", "parameters",
+    "middleware", "adapter", "request", "response", "upload_io", "error"
+
+  if !ENV["FARADAY_NO_AUTOLOAD"]
+    require_lib 'autoload'
+  end
 end

data/lib/faraday/adapter.rb

@@ -1,54 +1,43 @@
-# frozen_string_literal: true
-
 module Faraday
-  # Base class for all Faraday adapters. Adapters are
+  # Public: This is a base class for all Faraday adapters.  Adapters are
   # responsible for fulfilling a Faraday request.
-  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.
+  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.
     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 = supports_parallel?
+        subclass.supports_parallel = self.supports_parallel?
       end
     end
 
     extend Parallelism
     self.supports_parallel = false
 
-    def initialize(_app = nil, opts = {}, &block)
-      @app = ->(env) { env.response }
+    def initialize(app = nil, opts = {}, &block)
+      super(app)
       @connection_options = opts
       @config_block = block
     end
 
     def call(env)
       env.clear_body if env.needs_body?
-      env.response = Response.new
     end
 
     private
@@ -56,14 +45,11 @@ module Faraday
     def save_response(env, status, body, headers = nil, reason_phrase = nil)
       env.status = status
       env.body = body
-      env.reason_phrase = reason_phrase&.to_s&.strip
+      env.reason_phrase = 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
   end
 end

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 Faraday::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Faraday::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::ClientError
+        if msg == Errno::ETIMEDOUT
+          errklass = 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
+          errklass = Faraday::ConnectionFailed
+          msg = "connection refused"
+        elsif msg == "connection closed by server"
+          errklass = Faraday::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,10 +191,7 @@ module Faraday
           @running = false
         end
 
-        # @return [Boolean]
-        def running?
-          @running
-        end
+        def running?() @running end
 
         def add(&block)
           if running?
@@ -239,15 +203,15 @@ module Faraday
         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::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?