' + - member.author.login + - '
' + - '' + - 'Page not found :(
-The requested page could not be found.
-- {% if page.prev_link %} - {{ page.prev_name }} - {% endif %} -
-- {% if page.top_link %} - {{ page.top_name }} - {% endif %} -
-- {% if page.next_link %} - {{ page.next_name }} - {% endif %} -
-' + - member.author.login + - '
' + - '' + - '
-feature-img: "assets/img/featured-bg.svg"
-hide: true
----
-
-Faraday is an HTTP client library that provides a common interface over many adapters (such as Net::HTTP)
-and embraces the concept of Rack middleware when processing the request/response cycle.
-
-{: .text-center}
-[ Fork on GitHub][github]{: .btn}
-[ Chat with us][gitter]{: .btn}
-
-{: .mt-60}
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'faraday'
-```
-
-And then execute:
-
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-
-```bash
-$ gem install faraday
-```
-
-You can also install the [`faraday_middleware`][faraday_middleware]
-extension gem to access a collection of useful Faraday middleware.
-
-{: .mt-60}
-
-{: .text-center}
-[ Read the docs][usage]{: .btn}
-
-[github]: https://github.com/lostisland/faraday
-[gitter]: https://gitter.im/lostisland/faraday
-[faraday_middleware]: https://github.com/lostisland/faraday_middleware
-[usage]: ./usage
+# 
+
+Faraday is an HTTP client library abstraction layer that provides a common interface over many
+adapters (such as Net::HTTP) and embraces the concept of Rack middleware when processing the request/response cycle.
+
+## Why use Faraday?
+
+Faraday gives you the power of Rack middleware for manipulating HTTP requests and responses,
+making it easier to build sophisticated API clients or web service libraries that abstract away
+the details of how HTTP requests are made.
+
+Faraday comes with a lot of features out of the box, such as:
+* Support for multiple adapters (Net::HTTP, Typhoeus, Patron, Excon, HTTPClient, and more)
+* Persistent connections (keep-alive)
+* Parallel requests
+* Automatic response parsing (JSON, XML, YAML)
+* Customization of the request/response cycle with middleware
+* Support for streaming responses
+* Support for uploading files
+* And much more!
+
+## Who uses Faraday?
+
+Faraday is used by many popular Ruby libraries, such as:
+* [Signet](https://github.com/googleapis/signet)
+* [Octokit](https://github.com/octokit/octokit.rb)
+* [Oauth2](https://bestgems.org/gems/oauth2)
+* [Elasticsearch](https://github.com/elastic/elasticsearch-ruby)
diff --git a/docs/middleware/custom-middleware.md b/docs/middleware/custom-middleware.md
new file mode 100644
index 000000000..df15b80f0
--- /dev/null
+++ b/docs/middleware/custom-middleware.md
@@ -0,0 +1,84 @@
+# Writing custom middleware
+
+!> A template for writing your own middleware is available in the [faraday-middleware-template](https://github.com/lostisland/faraday-middleware-template) repository.
+
+The recommended way to write middleware is to make your middleware subclass `Faraday::Middleware`.
+`Faraday::Middleware` simply expects your subclass to implement two methods: `#on_request(env)` and `#on_complete(env)`.
+* `#on_request` is called when the request is being built and is given the `env` representing the request.
+* `#on_complete` is called after the response has been received (that's right, it already supports parallel mode!) and receives the `env` of the response.
+
+For both `env` parameters, please refer to the [Env Object](getting-started/env-object.md) page.
+
+```ruby
+class MyMiddleware < Faraday::Middleware
+ def on_request(env)
+ # do something with the request
+ # env[:request_headers].merge!(...)
+ end
+
+ def on_complete(env)
+ # do something with the response
+ # env[:response_headers].merge!(...)
+ end
+end
+```
+
+## Having more control
+
+For the majority of middleware, it's not necessary to override the `#call` method. You can instead use `#on_request` and `#on_complete`.
+
+However, in some cases you may need to wrap the call in a block, or work around it somehow (think of a begin-rescue, for example).
+When that happens, then you can override `#call`. When you do so, remember to call either `app.call(env)` or `super` to avoid breaking the middleware stack call!
+
+```ruby
+def call(request_env)
+ # do something with the request
+ # request_env[:request_headers].merge!(...)
+
+ @app.call(request_env).on_complete do |response_env|
+ # do something with the response
+ # response_env[:response_headers].merge!(...)
+ end
+end
+```
+
+It's important to do all processing of the response only in the `#on_complete`
+block. This enables middleware to work in parallel mode where requests are
+asynchronous.
+
+The `request_env` and `response_env` are both [Env Objects](getting-started/env-object.md) but note the amount of
+information available in each one will differ based on the request/response lifecycle.
+
+## Accepting configuration options
+
+`Faraday::Middleware` also allows your middleware to accept configuration options.
+These are passed in when the middleware is added to the stack, and can be accessed via the `options` getter.
+
+```ruby
+class MyMiddleware < Faraday::Middleware
+ def on_request(_env)
+ # access the foo option
+ puts options[:foo]
+ end
+end
+
+conn = Faraday.new(url: 'http://httpbingo.org') do |faraday|
+ faraday.use MyMiddleware, foo: 'bar'
+end
+```
+
+## Registering your middleware
+
+Users can use your middleware using the class directly, but you can also register it with Faraday so that
+it can be used with the `use`, `request` or `response` methods as well.
+
+```ruby
+# Register for `use`
+Faraday::Middleware.register_middleware(my_middleware: MyMiddleware)
+
+# Register for `request`
+Faraday::Request.register_middleware(my_middleware: MyMiddleware)
+
+# Register for `response`
+Faraday::Response.register_middleware(my_middleware: MyMiddleware)
+```
diff --git a/docs/middleware/custom.md b/docs/middleware/custom.md
deleted file mode 100644
index 5fa82b78c..000000000
--- a/docs/middleware/custom.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-layout: documentation
-title: "Writing Middleware"
-permalink: /middleware/custom
-hide: true
-top_name: Middleware
-top_link: ./
-prev_name: Available Middleware
-prev_link: ./list
----
-
-Middleware are classes that implement a `call` instance method. They hook into
-the request/response cycle.
-
-```ruby
-def call(request_env)
- # do something with the request
- # request_env[:request_headers].merge!(...)
-
- @app.call(request_env).on_complete do |response_env|
- # do something with the response
- # response_env[:response_headers].merge!(...)
- end
-end
-```
-
-It's important to do all processing of the response only in the `on_complete`
-block. This enables middleware to work in parallel mode where requests are
-asynchronous.
-
-The `env` is a hash with symbol keys that contains info about the request and,
-later, response. Some keys are:
-
-```
-# request phase
-:method - :get, :post, ...
-:url - URI for the current request; also contains GET parameters
-:body - POST parameters for :post/:put requests
-:request_headers
-
-# response phase
-:status - HTTP response status code, such as 200
-:body - the response body
-:response_headers
-```
diff --git a/docs/middleware/included/authentication.md b/docs/middleware/included/authentication.md
new file mode 100644
index 000000000..b0e5cc1fc
--- /dev/null
+++ b/docs/middleware/included/authentication.md
@@ -0,0 +1,65 @@
+# Authentication
+
+The `Faraday::Request::Authorization` middleware allows you to automatically add an `Authorization` header
+to your requests. It also features a handy helper to manage Basic authentication.
+**Please note the way you use this middleware in Faraday 1.x is different**,
+examples are available at the bottom of this page.
+
+```ruby
+Faraday.new(...) do |conn|
+ conn.request :authorization, 'Bearer', 'authentication-token'
+end
+```
+
+### With a proc
+
+You can also provide a proc, which will be evaluated on each request:
+
+```ruby
+Faraday.new(...) do |conn|
+ conn.request :authorization, 'Bearer', -> { MyAuthStorage.get_auth_token }
+end
+```
+
+If the proc takes an argument, it will receive the forwarded `env` (see [The Env Object](getting-started/env-object.md)):
+
+```ruby
+Faraday.new(...) do |conn|
+ conn.request :authorization, 'Bearer', ->(env) { MyAuthStorage.get_auth_token(env) }
+end
+```
+
+### Basic Authentication
+
+The middleware will automatically Base64 encode your Basic username and password:
+
+```ruby
+Faraday.new(...) do |conn|
+ conn.request :authorization, :basic, 'username', 'password'
+end
+```
+
+### Faraday 1.x usage
+
+In Faraday 1.x, the way you use this middleware is slightly different:
+
+```ruby
+# Basic Auth request
+# Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=
+Faraday.new(...) do |conn|
+ conn.request :basic_auth, 'username', 'password'
+end
+
+# Token Auth request
+# `options` are automatically converted into `key=value` format
+# Authorization: Token authentication-token Website and branding design: Elena Lo Piccolo
-Faraday.get "https://faraday.com".
+ def default_connection
+ @default_connection ||= Connection.new(default_connection_options)
+ end
+
+ # Gets the default connection options used when calling {Faraday#new}.
+ #
+ # @return [Faraday::ConnectionOptions]
+ def default_connection_options
+ @default_connection_options ||= ConnectionOptions.new
+ end
+
+ # Sets the default options used when calling {Faraday#new}.
+ #
+ # @param options [Hash, Faraday::ConnectionOptions]
+ def default_connection_options=(options)
+ @default_connection = nil
+ @default_connection_options = ConnectionOptions.from(options)
+ end
+
private
# Internal: Proxies method calls on the Faraday constant to
@@ -124,43 +153,5 @@ def method_missing(name, *args, &block)
self.root_path = File.expand_path __dir__
self.lib_path = File.expand_path 'faraday', __dir__
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
- # Faraday.get "https://faraday.com".
- def self.default_connection
- @default_connection ||= Connection.new(default_connection_options)
- end
-
- # Gets the default connection options used when calling {Faraday#new}.
- #
- # @return [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]
- def self.default_connection_options=(options)
- @default_connection = nil
- @default_connection_options = ConnectionOptions.from(options)
- end
-
- unless const_defined? :Timer
- require 'timeout'
- Timer = Timeout
- end
-
- require_libs 'utils', 'options', 'connection', 'rack_builder', 'parameters',
- 'middleware', 'adapter', 'request', 'response', 'error',
- 'file_part', 'param_part'
-
- require_lib 'autoload' unless ENV['FARADAY_NO_AUTOLOAD']
+ self.default_adapter_options = {}
end
diff --git a/lib/faraday/adapter.rb b/lib/faraday/adapter.rb
index 407c2367f..1d9a45084 100644
--- a/lib/faraday/adapter.rb
+++ b/lib/faraday/adapter.rb
@@ -5,28 +5,13 @@ module Faraday
# 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.
module Parallelism
attr_writer :supports_parallel
+
def supports_parallel?
@supports_parallel
end
@@ -41,7 +26,7 @@ def inherited(subclass)
self.supports_parallel = false
def initialize(_app = nil, opts = {}, &block)
- @app = ->(env) { env.response }
+ @app = lambda(&:response)
@connection_options = opts
@config_block = block
end
@@ -74,7 +59,7 @@ def call(env)
private
- def save_response(env, status, body, headers = nil, reason_phrase = nil)
+ def save_response(env, status, body, headers = nil, reason_phrase = nil, finished: true)
env.status = status
env.body = body
env.reason_phrase = reason_phrase&.to_s&.strip
@@ -83,7 +68,7 @@ def save_response(env, status, body, headers = nil, reason_phrase = nil)
yield(response_headers) if block_given?
end
- env.response.finish(env) unless env.parallel?
+ env.response.finish(env) unless env.parallel? || !finished
env.response
end
@@ -93,8 +78,7 @@ def save_response(env, status, body, headers = nil, reason_phrase = nil)
# @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
+ # :read_timeout, :write_timeout, or :open_timeout
#
# @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
# has been set.
@@ -113,3 +97,5 @@ def request_timeout(type, options)
}.freeze
end
end
+
+require 'faraday/adapter/test'
diff --git a/lib/faraday/adapter/em_http.rb b/lib/faraday/adapter/em_http.rb
deleted file mode 100644
index acadc35ff..000000000
--- a/lib/faraday/adapter/em_http.rb
+++ /dev/null
@@ -1,285 +0,0 @@
-# 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
- # 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)
- configure_timeout(options, env)
- configure_socket(options, env)
- configure_ssl(options, env)
- options
- end
-
- def request_config(env)
- options = {
- body: read_body(env),
- head: env[:request_headers]
- # keepalive: true,
- # file: 'path/to/file', # stream data off disk
- }
- configure_compression(options, env)
- options
- end
-
- def read_body(env)
- body = env[:body]
- 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]]
- }
- 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]
- }
- 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)
- }
- end
-
- # Reads out timeout settings from env into options
- def configure_timeout(options, env)
- 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)
- return unless (env[:method] == :get) &&
- !options[:head].key?('accept-encoding')
-
- options[:head]['accept-encoding'] = 'gzip, compressed'
- end
-
- def request_options(env)
- env[:request]
- end
- end
-
- include Options
-
- dependency 'em-http'
-
- self.supports_parallel = true
-
- # @return [Manager]
- def self.setup_parallel_manager(_options = nil)
- Manager.new
- end
-
- def call(env)
- super
- perform_request env
- @app.call env
- end
-
- 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
- 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 => e
- if e.message.include?('Proxy Authentication Required')
- raise Faraday::ConnectionFailed,
- %(407 "Proxy Authentication Required ")
- end
-
- 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 = 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 |headers|
- client.response_header.each do |name, 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)
- )
- end
-
- def error_message(client)
- client.error || 'request failed'
- end
-
- def raise_error(msg)
- error_class = Faraday::ClientError
- if timeout_message?(msg)
- error_class = 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
- end
- 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
-
- # 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
- @num_succeeded = 0
- @errors = []
- @running = false
- end
-
- # @return [Boolean]
- def running?
- @running
- end
-
- def add(&block)
- if running?
- perform_request { yield }
- else
- @registered_procs << block
- end
- @num_registered += 1
- end
-
- def run
- if @num_registered.positive?
- @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'
- end
- end
- ensure
- reset
- end
-
- def perform_request
- client = yield
- client.callback do
- @num_succeeded += 1
- check_finished
- end
- client.errback do
- @errors << client.error
- check_finished
- end
- end
-
- def check_finished
- EventMachine.stop if @num_succeeded + @errors.size == @num_registered
- 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
diff --git a/lib/faraday/adapter/em_http_ssl_patch.rb b/lib/faraday/adapter/em_http_ssl_patch.rb
deleted file mode 100644
index d33a9c4cf..000000000
--- a/lib/faraday/adapter/em_http_ssl_patch.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'openssl'
-require 'em-http'
-
-# EventMachine patch to make SSL work.
-module EmHttpSslPatch
- def ssl_verify_peer(cert_string)
- begin
- @last_seen_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'
- 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)
- 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
-
- def certificate_store
- @certificate_store ||= begin
- store = OpenSSL::X509::Store.new
- store.set_default_paths
- ca_file = parent.connopts.tls[:cert_chain_file]
- store.add_file(ca_file) if ca_file
- store
- end
- end
-end
-
-EventMachine::HttpStubConnection.include(EmHttpSslPatch)
diff --git a/lib/faraday/adapter/em_synchrony.rb b/lib/faraday/adapter/em_synchrony.rb
deleted file mode 100644
index 0e94c0dbe..000000000
--- a/lib/faraday/adapter/em_synchrony.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-
-module Faraday
- class Adapter
- # EventMachine Synchrony adapter.
- class EMSynchrony < Faraday::Adapter
- include EMHttp::Options
-
- dependency do
- require 'em-synchrony/em-http'
- require 'em-synchrony/em-multi'
- require 'fiber'
- end
-
- self.supports_parallel = true
-
- # @return [ParallelManager]
- def self.setup_parallel_manager(_options = nil)
- ParallelManager.new
- end
-
- def call(env)
- super
- request = create_request(env)
-
- http_method = env[:method].to_s.downcase.to_sym
-
- if env[:parallel_manager]
- # Queue requests for parallel execution.
- execute_parallel_request(env, request, http_method)
- else
- # Execute single request.
- execute_single_request(env, request, http_method)
- end
-
- @app.call env
- rescue Errno::ECONNREFUSED
- raise Faraday::ConnectionFailed, $ERROR_INFO
- rescue EventMachine::Connectify::CONNECTError => e
- if e.message.include?('Proxy Authentication Required')
- raise Faraday::ConnectionFailed,
- %(407 "Proxy Authentication Required")
- end
-
- raise Faraday::ConnectionFailed, e
- rescue Errno::ETIMEDOUT => e
- raise Faraday::TimeoutError, e
- rescue RuntimeError => e
- if e.message == 'connection closed by server'
- raise Faraday::ConnectionFailed, e
- end
-
- raise Faraday::TimeoutError, e if e.message.include?('timeout error')
-
- raise
- rescue StandardError => e
- if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
- raise Faraday::SSLError, e
- end
-
- raise
- end
-
- def create_request(env)
- EventMachine::HttpRequest.new(
- Utils::URI(env[:url].to_s),
- connection_config(env).merge(@connection_options)
- )
- end
-
- private
-
- def execute_parallel_request(env, request, http_method)
- env[:parallel_manager].add(request, http_method,
- request_config(env)) do |resp|
- if (req = env[:request]).stream_response?
- warn "Streaming downloads for #{self.class.name} " \
- 'are not yet implemented.'
- req.on_data.call(resp.response, resp.response.bytesize)
- end
-
- save_response(env, resp.response_header.status,
- resp.response) do |resp_headers|
- resp.response_header.each do |name, value|
- resp_headers[name.to_sym] = value
- end
- end
-
- # Finalize the response object with values from `env`.
- env[:response].finish(env)
- end
- end
-
- def execute_single_request(env, request, http_method)
- block = -> { request.send(http_method, request_config(env)) }
- client = call_block(block)
-
- raise client.error if client&.error
-
- 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 |headers|
- client.response_header.each do |name, value|
- headers[name.to_sym] = value
- end
- end
- end
-
- def call_block(block)
- client = nil
-
- if EM.reactor_running?
- client = block.call
- else
- EM.run do
- Fiber.new do
- client = block.call
- EM.stop
- end.resume
- end
- end
-
- client
- end
- end
- end
-end
-
-require 'faraday/adapter/em_synchrony/parallel_manager'
-
-if Faraday::Adapter::EMSynchrony.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
diff --git a/lib/faraday/adapter/em_synchrony/parallel_manager.rb b/lib/faraday/adapter/em_synchrony/parallel_manager.rb
deleted file mode 100644
index 1701ae82d..000000000
--- a/lib/faraday/adapter/em_synchrony/parallel_manager.rb
+++ /dev/null
@@ -1,69 +0,0 @@
-# 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
- def add(request, method, *args, &block)
- queue << {
- request: request,
- method: method,
- args: args,
- block: block
- }
- end
-
- # Run all requests on queue with `EM::Synchrony::Multi`, wrapping
- # it in a reactor and fiber if needed.
- def run
- result = nil
- if !EM.reactor_running?
- EM.run do
- Fiber.new do
- result = perform
- EM.stop
- end.resume
- end
- else
- result = perform
- end
- result
- end
-
- private
-
- # The request queue.
- def queue
- @queue ||= []
- end
-
- # Main `EM::Synchrony::Multi` performer.
- def perform
- multi = ::EM::Synchrony::Multi.new
-
- queue.each do |item|
- method = "a#{item[:method]}".to_sym
-
- req = item[:request].send(method, *item[:args])
- req.callback(&item[:block])
-
- req_name = "req_#{multi.requests.size}".to_sym
- multi.add(req_name, req)
- end
-
- # Clear the queue, so parallel manager objects can be reused.
- @queue = []
-
- # Block fiber until all requests have returned.
- multi.perform
- end
- end
- end
- end
-end
diff --git a/lib/faraday/adapter/excon.rb b/lib/faraday/adapter/excon.rb
deleted file mode 100644
index 2ba264e3b..000000000
--- a/lib/faraday/adapter/excon.rb
+++ /dev/null
@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
- class Adapter
- # Excon adapter.
- class Excon < Faraday::Adapter
- dependency 'excon'
-
- def build_connection(env)
- opts = opts_from_env(env)
- ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
- end
-
- def call(env)
- super
-
- req_opts = {
- method: env[:method].to_s.upcase,
- headers: env[:request_headers],
- body: read_body(env)
- }
-
- req = env[:request]
- if req&.stream_response?
- total = 0
- req_opts[:response_block] = lambda do |chunk, _remain, _total|
- req.on_data.call(chunk, total += chunk.size)
- end
- end
-
- resp = connection(env) { |http| http.request(req_opts) }
- save_response(env, resp.status.to_i, resp.body, resp.headers,
- resp.reason_phrase)
-
- @app.call(env)
- rescue ::Excon::Errors::SocketError => e
- raise Faraday::TimeoutError, e if e.message =~ /\btimeout\b/
-
- raise Faraday::SSLError, e if e.message =~ /\bcertificate\b/
-
- raise Faraday::ConnectionFailed, e
- rescue ::Excon::Errors::Timeout => e
- raise Faraday::TimeoutError, e
- end
-
- # TODO: support streaming requests
- def read_body(env)
- env[:body].respond_to?(:read) ? env[:body].read : env[:body]
- end
-
- private
-
- def opts_from_env(env)
- opts = {}
- amend_opts_with_ssl!(opts, env[:ssl]) if needs_ssl_settings?(env)
-
- if (req = env[:request])
- amend_opts_with_timeouts!(opts, req)
- amend_opts_with_proxy_settings!(opts, req)
- end
-
- opts
- end
-
- def needs_ssl_settings?(env)
- env[:url].scheme == 'https' && env[:ssl]
- end
-
- OPTS_KEYS = [
- %i[client_cert client_cert],
- %i[client_key client_key],
- %i[certificate certificate],
- %i[private_key private_key],
- %i[ssl_ca_path ca_path],
- %i[ssl_ca_file ca_file],
- %i[ssl_version version],
- %i[ssl_min_version min_version],
- %i[ssl_max_version max_version]
- ].freeze
-
- def amend_opts_with_ssl!(opts, ssl)
- opts[:ssl_verify_peer] = !!ssl.fetch(:verify, true)
- # https://github.com/geemus/excon/issues/106
- # https://github.com/jruby/jruby-ossl/issues/19
- opts[:nonblock] = false
-
- OPTS_KEYS.each do |(key_in_opts, key_in_ssl)|
- next unless ssl[key_in_ssl]
-
- opts[key_in_opts] = ssl[key_in_ssl]
- end
- end
-
- def amend_opts_with_timeouts!(opts, req)
- if (sec = request_timeout(:read, req))
- opts[:read_timeout] = sec
- end
-
- if (sec = request_timeout(:write, req))
- opts[:write_timeout] = sec
- end
-
- return unless (sec = request_timeout(:open, req))
-
- opts[:connect_timeout] = sec
- end
-
- def amend_opts_with_proxy_settings!(opts, req)
- opts[:proxy] = proxy_settings_for_opts(req[:proxy]) if req[:proxy]
- end
-
- def proxy_settings_for_opts(proxy)
- {
- host: proxy[:uri].host,
- hostname: proxy[:uri].hostname,
- port: proxy[:uri].port,
- scheme: proxy[:uri].scheme,
- user: proxy[:user],
- password: proxy[:password]
- }
- end
- end
- end
-end
diff --git a/lib/faraday/adapter/httpclient.rb b/lib/faraday/adapter/httpclient.rb
deleted file mode 100644
index 539c15aaa..000000000
--- a/lib/faraday/adapter/httpclient.rb
+++ /dev/null
@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
- class Adapter
- # HTTPClient adapter.
- class HTTPClient < Faraday::Adapter
- dependency 'httpclient'
-
- def build_connection(env)
- @client ||= ::HTTPClient.new.tap do |cli|
- # enable compression
- cli.transparent_gzip_decompression = true
- end
-
- if (req = env[:request])
- if (proxy = req[:proxy])
- configure_proxy @client, proxy
- end
-
- if (bind = req[:bind])
- configure_socket @client, bind
- end
-
- configure_timeouts @client, req
- end
-
- if env[:url].scheme == 'https' && (ssl = env[:ssl])
- configure_ssl @client, ssl
- end
-
- configure_client @client
-
- @client
- end
-
- def call(env)
- super
-
- # TODO: Don't stream yet.
- # https://github.com/nahi/httpclient/pull/90
- env[:body] = env[:body].read if env[:body].respond_to? :read
-
- connection(env) do |http|
- resp = http.request env[:method], env[:url],
- body: env[:body],
- header: env[:request_headers]
-
- if (req = env[:request]).stream_response?
- warn "Streaming downloads for #{self.class.name} " \
- 'are not yet implemented.'
- req.on_data.call(resp.body, resp.body.bytesize)
- end
- save_response env, resp.status, resp.body, resp.headers, resp.reason
-
- @app.call env
- end
- rescue ::HTTPClient::TimeoutError, Errno::ETIMEDOUT
- raise Faraday::TimeoutError, $ERROR_INFO
- rescue ::HTTPClient::BadResponseError => e
- if e.message.include?('status 407')
- raise Faraday::ConnectionFailed,
- %(407 "Proxy Authentication Required ")
- end
-
- raise Faraday::ClientError, $ERROR_INFO
- rescue Errno::EADDRNOTAVAIL, Errno::ECONNREFUSED, IOError, SocketError
- raise Faraday::ConnectionFailed, $ERROR_INFO
- rescue StandardError => e
- if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
- raise Faraday::SSLError, e
- end
-
- raise
- end
-
- # @param bind [Hash]
- def configure_socket(client, bind)
- client.socket_local.host = bind[:host]
- client.socket_local.port = bind[:port]
- end
-
- # Configure proxy URI and any user credentials.
- #
- # @param proxy [Hash]
- def configure_proxy(client, proxy)
- client.proxy = proxy[:uri]
- return unless proxy[:user] && proxy[:password]
-
- client.set_proxy_auth(proxy[:user], proxy[:password])
- end
-
- # @param ssl [Hash]
- def configure_ssl(client, ssl)
- ssl_config = client.ssl_config
- ssl_config.verify_mode = ssl_verify_mode(ssl)
- ssl_config.cert_store = ssl_cert_store(ssl)
-
- ssl_config.add_trust_ca ssl[:ca_file] if ssl[:ca_file]
- ssl_config.add_trust_ca ssl[:ca_path] if ssl[:ca_path]
- ssl_config.client_cert = ssl[:client_cert] if ssl[:client_cert]
- ssl_config.client_key = ssl[:client_key] if ssl[:client_key]
- ssl_config.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
- end
-
- # @param req [Hash]
- def configure_timeouts(client, req)
- if (sec = request_timeout(:open, req))
- client.connect_timeout = sec
- end
-
- if (sec = request_timeout(:write, req))
- client.send_timeout = sec
- end
-
- return unless (sec = request_timeout(:read, req))
-
- client.receive_timeout = sec
- end
-
- def configure_client(client)
- @config_block&.call(client)
- end
-
- # @param ssl [Hash]
- # @return [OpenSSL::X509::Store]
- def ssl_cert_store(ssl)
- return ssl[:cert_store] if ssl[:cert_store]
-
- # Memoize the cert store so that the same one is passed to
- # HTTPClient each time, to avoid resyncing SSL sessions when
- # it's changed
- @ssl_cert_store ||= begin
- # Use the default cert store by default, i.e. system ca certs
- OpenSSL::X509::Store.new.tap(&:set_default_paths)
- end
- end
-
- # @param ssl [Hash]
- def ssl_verify_mode(ssl)
- ssl[:verify_mode] || begin
- if ssl.fetch(:verify, true)
- OpenSSL::SSL::VERIFY_PEER |
- OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
- else
- OpenSSL::SSL::VERIFY_NONE
- end
- end
- end
- end
- end
-end
diff --git a/lib/faraday/adapter/net_http.rb b/lib/faraday/adapter/net_http.rb
deleted file mode 100644
index 191568dd4..000000000
--- a/lib/faraday/adapter/net_http.rb
+++ /dev/null
@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-begin
- require 'net/https'
-rescue LoadError
- warn 'Warning: no such file to load -- net/https. ' \
- 'Make sure openssl is installed if you want ssl support'
- require 'net/http'
-end
-require 'zlib'
-
-module Faraday
- class Adapter
- # Net::HTTP adapter.
- class NetHttp < Faraday::Adapter
- exceptions = [
- IOError,
- Errno::EADDRNOTAVAIL,
- Errno::ECONNABORTED,
- Errno::ECONNREFUSED,
- Errno::ECONNRESET,
- Errno::EHOSTUNREACH,
- Errno::EINVAL,
- Errno::ENETUNREACH,
- Errno::EPIPE,
- Net::HTTPBadResponse,
- Net::HTTPHeaderSyntaxError,
- Net::ProtocolError,
- SocketError,
- Zlib::GzipFile::Error
- ]
-
- exceptions << OpenSSL::SSL::SSLError if defined?(OpenSSL)
- exceptions << Net::OpenTimeout if defined?(Net::OpenTimeout)
-
- NET_HTTP_EXCEPTIONS = exceptions.freeze
-
- def initialize(app = nil, opts = {}, &block)
- @ssl_cert_store = nil
- super(app, opts, &block)
- end
-
- def build_connection(env)
- net_http_connection(env).tap do |http|
- if http.respond_to?(:use_ssl=)
- http.use_ssl = env[:url].scheme == 'https'
- end
- configure_ssl(http, env[:ssl])
- configure_request(http, env[:request])
- end
- end
-
- def net_http_connection(env)
- klass = if (proxy = env[:request][:proxy])
- Net::HTTP::Proxy(proxy[:uri].hostname, proxy[:uri].port,
- proxy[:user], proxy[:password])
- else
- Net::HTTP
- end
- port = env[:url].port || (env[:url].scheme == 'https' ? 443 : 80)
- klass.new(env[:url].hostname, port)
- end
-
- def call(env)
- super
- http_response = connection(env) do |http|
- begin
- perform_request(http, env)
- rescue *NET_HTTP_EXCEPTIONS => e
- if defined?(OpenSSL) && e.is_a?(OpenSSL::SSL::SSLError)
- raise Faraday::SSLError, e
- end
-
- raise Faraday::ConnectionFailed, e
- end
- end
-
- save_response(env, http_response.code.to_i,
- http_response.body || +'', nil,
- http_response.message) do |response_headers|
- http_response.each_header do |key, value|
- response_headers[key] = value
- end
- end
-
- @app.call env
- rescue Timeout::Error, Errno::ETIMEDOUT => e
- raise Faraday::TimeoutError, e
- end
-
- private
-
- def create_request(env)
- request = Net::HTTPGenericRequest.new \
- env[:method].to_s.upcase, # request method
- !!env[:body], # is there request body
- env[:method] != :head, # is there response body
- env[:url].request_uri, # request uri path
- env[:request_headers] # request headers
-
- if env[:body].respond_to?(:read)
- request.body_stream = env[:body]
- else
- request.body = env[:body]
- end
- request
- end
-
- def perform_request(http, env)
- if env[:request].stream_response?
- size = 0
- yielded = false
- http_response = request_with_wrapped_block(http, env) do |chunk|
- if chunk.bytesize.positive? || size.positive?
- yielded = true
- size += chunk.bytesize
- env[:request].on_data.call(chunk, size)
- end
- end
- env[:request].on_data.call(+'', 0) unless yielded
- # Net::HTTP returns something,
- # but it's not meaningful according to the docs.
- http_response.body = nil
- http_response
- else
- request_with_wrapped_block(http, env)
- end
- end
-
- def request_with_wrapped_block(http, env, &block)
- if (env[:method] == :get) && !env[:body]
- # prefer `get` to `request` because the former handles gzip (ruby 1.9)
- request_via_get_method(http, env, &block)
- else
- request_via_request_method(http, env, &block)
- end
- end
-
- def request_via_get_method(http, env, &block)
- http.get env[:url].request_uri, env[:request_headers], &block
- end
-
- def request_via_request_method(http, env, &block)
- if block_given?
- http.request create_request(env) do |response|
- response.read_body(&block)
- end
- else
- http.request create_request(env)
- end
- end
-
- def configure_ssl(http, ssl)
- return unless ssl
-
- http.verify_mode = ssl_verify_mode(ssl)
- http.cert_store = ssl_cert_store(ssl)
-
- http.cert = ssl[:client_cert] if ssl[:client_cert]
- http.key = ssl[:client_key] if ssl[:client_key]
- http.ca_file = ssl[:ca_file] if ssl[:ca_file]
- http.ca_path = ssl[:ca_path] if ssl[:ca_path]
- http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
- http.ssl_version = ssl[:version] if ssl[:version]
- http.min_version = ssl[:min_version] if ssl[:min_version]
- http.max_version = ssl[:max_version] if ssl[:max_version]
- end
-
- def configure_request(http, req)
- if (sec = request_timeout(:read, req))
- http.read_timeout = sec
- end
-
- if (sec = http.respond_to?(:write_timeout=) &&
- request_timeout(:write, req))
- http.write_timeout = sec
- end
-
- if (sec = request_timeout(:open, req))
- http.open_timeout = sec
- end
-
- # Only set if Net::Http supports it, since Ruby 2.5.
- http.max_retries = 0 if http.respond_to?(:max_retries=)
-
- @config_block&.call(http)
- end
-
- def ssl_cert_store(ssl)
- return ssl[:cert_store] if ssl[:cert_store]
-
- @ssl_cert_store ||= begin
- # Use the default cert store by default, i.e. system ca certs
- OpenSSL::X509::Store.new.tap(&:set_default_paths)
- end
- end
-
- def ssl_verify_mode(ssl)
- ssl[:verify_mode] || begin
- if ssl.fetch(:verify, true)
- OpenSSL::SSL::VERIFY_PEER
- else
- OpenSSL::SSL::VERIFY_NONE
- end
- end
- end
- end
- end
-end
diff --git a/lib/faraday/adapter/net_http_persistent.rb b/lib/faraday/adapter/net_http_persistent.rb
deleted file mode 100644
index ff20c2567..000000000
--- a/lib/faraday/adapter/net_http_persistent.rb
+++ /dev/null
@@ -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 => 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
diff --git a/lib/faraday/adapter/patron.rb b/lib/faraday/adapter/patron.rb
deleted file mode 100644
index c6e2935fb..000000000
--- a/lib/faraday/adapter/patron.rb
+++ /dev/null
@@ -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
diff --git a/lib/faraday/adapter/rack.rb b/lib/faraday/adapter/rack.rb
deleted file mode 100644
index 6a237ee13..000000000
--- a/lib/faraday/adapter/rack.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
- class Adapter
- # Sends requests to a Rack app.
- #
- # @example
- #
- # class MyRackApp
- # def call(env)
- # [200, {'Content-Type' => 'text/html'}, ["hello world"]]
- # end
- # end
- #
- # Faraday.new do |conn|
- # conn.adapter :rack, MyRackApp.new
- # end
- class Rack < Faraday::Adapter
- dependency 'rack/test'
-
- # not prefixed with "HTTP_"
- SPECIAL_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE].freeze
-
- def initialize(faraday_app, rack_app)
- super(faraday_app)
- mock_session = ::Rack::MockSession.new(rack_app)
- @session = ::Rack::Test::Session.new(mock_session)
- end
-
- def call(env)
- super
- rack_env = build_rack_env(env)
-
- env[:request_headers]&.each do |name, value|
- name = name.upcase.tr('-', '_')
- name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
- rack_env[name] = value
- end
-
- timeout = request_timeout(:open, env[:request])
- timeout ||= request_timeout(:read, env[:request])
- response = if timeout
- Timer.timeout(timeout, Faraday::TimeoutError) do
- execute_request(env, rack_env)
- end
- else
- execute_request(env, rack_env)
- 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
-
- save_response(env, response.status, response.body, response.headers)
- @app.call env
- end
-
- private
-
- def execute_request(env, rack_env)
- @session.request(env[:url].to_s, rack_env)
- end
-
- def build_rack_env(env)
- {
- method: env[:method],
- input: env[:body].respond_to?(:read) ? env[:body].read : env[:body],
- 'rack.url_scheme' => env[:url].scheme
- }
- end
- end
- end
-end
diff --git a/lib/faraday/adapter/test.rb b/lib/faraday/adapter/test.rb
index 0230b853f..c637d139a 100644
--- a/lib/faraday/adapter/test.rb
+++ b/lib/faraday/adapter/test.rb
@@ -1,5 +1,7 @@
# frozen_string_literal: true
+require 'timeout'
+
module Faraday
class Adapter
# @example
@@ -25,6 +27,18 @@ class Adapter
# "showing item: #{meta[:match_data][1]}"
# ]
# end
+ #
+ # # Test the request body is the same as the stubbed body
+ # stub.post('/bar', 'name=YK&word=call') { [200, {}, ''] }
+ #
+ # # You can pass a proc as a stubbed body and check the request body in your way.
+ # # In this case, the proc should return true or false.
+ # stub.post('/foo', ->(request_body) do
+ # JSON.parse(request_body).slice('name') == { 'name' => 'YK' } }) { [200, {}, '']
+ # end
+ #
+ # # You can set strict_mode to exactly match the stubbed requests.
+ # stub.strict_mode = true
# end
# end
#
@@ -39,6 +53,12 @@ class Adapter
#
# resp = test.get '/items/2'
# resp.body # => 'showing item: 2'
+ #
+ # resp = test.post '/bar', 'name=YK&word=call'
+ # resp.status # => 200
+ #
+ # resp = test.post '/foo', JSON.dump(name: 'YK', created_at: Time.now)
+ # resp.status # => 200
class Test < Faraday::Adapter
attr_accessor :stubs
@@ -47,10 +67,12 @@ class Stubs
class NotFound < StandardError
end
- def initialize
+ def initialize(strict_mode: false)
# { get: [Stub, Stub] }
@stack = {}
@consumed = {}
+ @strict_mode = strict_mode
+ @stubs_mutex = Monitor.new
yield(self) if block_given?
end
@@ -58,18 +80,23 @@ def empty?
@stack.empty?
end
- def match(request_method, host, path, headers, body)
+ # @param env [Faraday::Env]
+ def match(env)
+ request_method = env[:method]
return false unless @stack.key?(request_method)
stack = @stack[request_method]
consumed = (@consumed[request_method] ||= [])
- stub, meta = matches?(stack, host, path, headers, body)
- if stub
- consumed << stack.delete(stub)
- return stub, meta
+ @stubs_mutex.synchronize do
+ stub, meta = matches?(stack, env)
+ if stub
+ removed = stack.delete(stub)
+ consumed << removed unless removed.nil?
+ return stub, meta
+ end
end
- matches?(consumed, host, path, headers, body)
+ matches?(consumed, env)
end
def get(path, headers = {}, &block)
@@ -115,6 +142,17 @@ def verify_stubbed_calls
raise failed_stubs.join(' ') unless failed_stubs.empty?
end
+ # Set strict_mode. If the value is true, this adapter tries to find matched requests strictly,
+ # which means that all of a path, parameters, and headers must be the same as an actual request.
+ def strict_mode=(value)
+ @strict_mode = value
+ @stack.each_value do |stubs|
+ stubs.each do |stub|
+ stub.strict_mode = value
+ end
+ end
+ end
+
protected
def new_stub(request_method, path, headers = {}, body = nil, &block)
@@ -127,14 +165,18 @@ def new_stub(request_method, path, headers = {}, body = nil, &block)
Faraday::Utils.URI(path).host
]
end
+ path, query = normalized_path.respond_to?(:split) ? normalized_path.split('?') : normalized_path
+ headers = Utils::Headers.new(headers)
- stub = Stub.new(host, normalized_path, headers, body, block)
+ stub = Stub.new(host, path, query, headers, body, @strict_mode, block)
(@stack[request_method] ||= []) << stub
end
- def matches?(stack, host, path, headers, body)
+ # @param stack [Hash]
+ # @param env [Faraday::Env]
+ def matches?(stack, env)
stack.each do |stub|
- match_result, meta = stub.matches?(host, path, headers, body)
+ match_result, meta = stub.matches?(env)
return stub, meta if match_result
end
nil
@@ -142,36 +184,21 @@ def matches?(stack, host, path, headers, body)
end
# Stub request
- # rubocop:disable Style/StructInheritance
- class Stub < Struct.new(:host, :path, :params, :headers, :body, :block)
- # rubocop:enable Style/StructInheritance
- def initialize(host, full, headers, body, block)
- path, query = full.respond_to?(:split) ? full.split('?') : full
- params =
- if query
- Faraday::Utils.parse_nested_query(query)
- else
- {}
- end
+ Stub = Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) do
+ # @param env [Faraday::Env]
+ def matches?(env)
+ request_host = env[:url].host
+ request_path = Faraday::Utils.normalize_path(env[:url].path)
+ request_headers = env.request_headers
+ request_body = env[:body]
- super(host, path, params, headers, body, block)
- end
-
- def matches?(request_host, request_uri, request_headers, request_body)
- request_path, request_query = request_uri.split('?')
- request_params =
- if request_query
- Faraday::Utils.parse_nested_query(request_query)
- else
- {}
- end
# meta is a hash used as carrier
# that will be yielded to consumer block
meta = {}
[(host.nil? || host == request_host) &&
path_match?(request_path, meta) &&
- params_match?(request_params) &&
- (body.to_s.size.zero? || request_body == body) &&
+ params_match?(env) &&
+ body_match?(request_body) &&
headers_match?(request_headers), meta]
end
@@ -183,18 +210,46 @@ def path_match?(request_path, meta)
end
end
- def params_match?(request_params)
+ # @param env [Faraday::Env]
+ def params_match?(env)
+ request_params = env[:params]
+ params = env.params_encoder.decode(query) || {}
+
+ if strict_mode
+ return Set.new(params) == Set.new(request_params)
+ end
+
params.keys.all? do |key|
request_params[key] == params[key]
end
end
def headers_match?(request_headers)
+ if strict_mode
+ headers_with_user_agent = headers.dup.tap do |hs|
+ # NOTE: Set User-Agent in case it's not set when creating Stubs.
+ # Users would not want to set Faraday's User-Agent explicitly.
+ hs[:user_agent] ||= Connection::USER_AGENT
+ end
+ return Set.new(headers_with_user_agent) == Set.new(request_headers)
+ end
+
headers.keys.all? do |key|
request_headers[key] == headers[key]
end
end
+ def body_match?(request_body)
+ return true if body.to_s.empty?
+
+ case body
+ when Proc
+ body.call(request_body)
+ else
+ request_body == body
+ end
+ end
+
def to_s
"#{path} #{body}"
end
@@ -210,37 +265,47 @@ def configure
yield(stubs)
end
+ # @param env [Faraday::Env]
def call(env)
super
- host = env[:url].host
- normalized_path = Faraday::Utils.normalize_path(env[:url])
- params_encoder = env.request.params_encoder ||
- Faraday::Utils.default_params_encoder
- stub, meta = stubs.match(env[:method], host, normalized_path,
- env.request_headers, env[:body])
+ env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+ env[:params] = env.params_encoder.decode(env[:url].query) || {}
+ stub, meta = stubs.match(env)
unless stub
- raise Stubs::NotFound, "no stubbed request for #{env[:method]} "\
- "#{normalized_path} #{env[:body]}"
+ raise Stubs::NotFound, "no stubbed request for #{env[:method]} " \
+ "#{env[:url]} #{env[:body]} #{env[:headers]}"
end
- env[:params] = if (query = env[:url].query)
- params_encoder.decode(query)
- else
- {}
- end
block_arity = stub.block.arity
+ params = if block_arity >= 0
+ [env, meta].take(block_arity)
+ else
+ [env, meta]
+ end
+
+ timeout = request_timeout(:open, env[:request])
+ timeout ||= request_timeout(:read, env[:request])
+
status, headers, body =
- if block_arity >= 0
- stub.block.call(*[env, meta].take(block_arity))
+ if timeout
+ ::Timeout.timeout(timeout, Faraday::TimeoutError) do
+ stub.block.call(*params)
+ end
else
- stub.block.call(env, meta)
+ stub.block.call(*params)
end
- save_response(env, status, body, headers)
+
+ # We need to explicitly pass `reason_phrase = nil` here to avoid keyword args conflicts.
+ # See https://github.com/lostisland/faraday/issues/1444
+ # TODO: remove `nil` explicit reason_phrase once Ruby 3.0 becomes minimum req. version
+ save_response(env, status, body, headers, nil)
@app.call(env)
end
end
end
end
+
+Faraday::Adapter.register_middleware(test: Faraday::Adapter::Test)
diff --git a/lib/faraday/adapter/typhoeus.rb b/lib/faraday/adapter/typhoeus.rb
deleted file mode 100644
index 306c0e45d..000000000
--- a/lib/faraday/adapter/typhoeus.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
- class Adapter
- # Typhoeus adapter. This class is just a stub, the real adapter is in
- # https://github.com/philsturgeon/typhoeus/blob/master/lib/typhoeus/adapters/faraday.rb
- class Typhoeus < Faraday::Adapter
- # Needs to define this method in order to support Typhoeus <= 1.3.0
- def call; end
-
- dependency 'typhoeus'
- dependency 'typhoeus/adapters/faraday'
- end
- end
-end
diff --git a/lib/faraday/adapter_registry.rb b/lib/faraday/adapter_registry.rb
index 7b08c57ad..1cd1e7e17 100644
--- a/lib/faraday/adapter_registry.rb
+++ b/lib/faraday/adapter_registry.rb
@@ -12,7 +12,9 @@ def initialize
end
def get(name)
- klass = @constants[name]
+ klass = @lock.synchronize do
+ @constants[name]
+ end
return klass if klass
Object.const_get(name).tap { |c| set(c, name) }
diff --git a/lib/faraday/autoload.rb b/lib/faraday/autoload.rb
deleted file mode 100644
index 20863bebc..000000000
--- a/lib/faraday/autoload.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
- # Adds the ability for other modules to manage autoloadable
- # constants.
- #
- # @api private
- module AutoloadHelper
- # Registers the constants to be auto loaded.
- #
- # @param prefix [String] The require prefix. If the path is inside Faraday,
- # then it will be prefixed with the root path of this loaded
- # Faraday version.
- # @param options [{ Symbol => String }] library names.
- #
- # @example
- #
- # Faraday.autoload_all 'faraday/foo',
- # Bar: 'bar'
- #
- # # requires faraday/foo/bar to load Faraday::Bar.
- # Faraday::Bar
- #
- # @return [void]
- def autoload_all(prefix, options)
- if prefix =~ %r{^faraday(/|$)}i
- prefix = File.join(Faraday.root_path, prefix)
- end
-
- options.each do |const_name, path|
- autoload const_name, File.join(prefix, path)
- end
- end
-
- # Loads each autoloaded constant. If thread safety is a concern,
- # wrap this in a Mutex.
- #
- # @return [void]
- def load_autoloaded_constants
- constants.each do |const|
- const_get(const) if autoload?(const)
- end
- end
-
- # Filters the module's contents with those that have been already
- # autoloaded.
- #
- # @return [Array