class Faraday::RackBuilder

A Builder that processes requests into responses by passing through an inner middleware stack (heavily inspired by Rack).

@example

Faraday::Connection.new(url: 'http://httpbingo.org') do |builder|
  builder.request  :url_encoded  # Faraday::Request::UrlEncoded
  builder.adapter  :net_http     # Faraday::Adapter::NetHttp
end

Constants

LOCK_ERR
MISSING_ADAPTER_ERROR
NO_ARGUMENT: Used to detect missing arguments

Attributes

handlers [RW]

Public Class Methods

new (&block)

# File lib/faraday/rack_builder.rb, line 66
def initialize(&block)
  @adapter = nil
  @handlers = []
  build(&block)
end

Public Instance Methods

== (other)

# File lib/faraday/rack_builder.rb, line 188
def ==(other)
  other.is_a?(self.class) &&
    @handlers == other.handlers &&
    @adapter == other.adapter
end

[] (idx)

# File lib/faraday/rack_builder.rb, line 87
def [](idx)
  @handlers[idx]
end

adapter (klass = NO_ARGUMENT, *args, **kwargs, &block)

# File lib/faraday/rack_builder.rb, line 118
def adapter(klass = NO_ARGUMENT, *args, **kwargs, &block)
  return @adapter if klass == NO_ARGUMENT || klass.nil?

  raise_if_locked
  klass = Faraday::Adapter.lookup_middleware(klass) if klass.is_a?(Symbol)
  @adapter = self.class::Handler.new(klass, *args, **kwargs, &block)
end

app ()

The “rack app” wrapped in middleware. All requests are sent here.

The builder is responsible for creating the app object. After this, the builder gets locked to ensure no further modifications are made to the middleware stack.

Returns an object that responds to ‘call` and returns a Response.

# File lib/faraday/rack_builder.rb, line 172
def app
  @app ||= begin
    lock!
    ensure_adapter!
    to_app
  end
end

build () { |self| ... }

# File lib/faraday/rack_builder.rb, line 81
def build
  raise_if_locked
  block_given? ? yield(self) : request(:url_encoded)
  adapter(Faraday.default_adapter, **Faraday.default_adapter_options) unless @adapter
end

build_env (connection, request)

ENV Keys :http_method - a symbolized request HTTP method (:get, :post) :body - the request body that will eventually be converted to a string. :url - URI instance for the current request. :status - HTTP response status code :request_headers - hash of HTTP Headers to be sent to the server :response_headers - Hash of HTTP headers from the server :parallel_manager - sent if the connection is in parallel mode :request - Hash of options for configuring the request.

:timeout      - open/read timeout Integer in seconds
:open_timeout - read timeout Integer in seconds
:proxy        - Hash of proxy options
  :uri        - Proxy Server URI
  :user       - Proxy server username
  :password   - Proxy server password

:ssl - Hash of options for configuring SSL requests.

# File lib/faraday/rack_builder.rb, line 210
def build_env(connection, request)
  exclusive_url = connection.build_exclusive_url(
    request.path, request.params,
    request.options.params_encoder
  )

  Env.new(request.http_method, request.body, exclusive_url,
          request.options, request.headers, connection.ssl,
          connection.parallel_manager)
end

build_response (connection, request)

Processes a Request into a Response by passing it through this Builder’s middleware stack.

@param connection [Faraday::Connection] @param request [Faraday::Request]

@return [Faraday::Response]

# File lib/faraday/rack_builder.rb, line 161
def build_response(connection, request)
  app.call(build_env(connection, request))
end

delete (handler)

# File lib/faraday/rack_builder.rb, line 149
def delete(handler)
  raise_if_locked
  @handlers.delete(handler)
end

initialize_dup (original)

Calls superclass method

# File lib/faraday/rack_builder.rb, line 72
def initialize_dup(original)
  super
  @adapter = original.adapter
  @handlers = original.handlers.dup
  # @app is memoized on the first request. Drop it so the duplicate
  # rebuilds from the copied handlers and middleware added after dup runs.
  @app = nil
end

insert (index, ...)

methods to push onto the various positions in the stack:

# File lib/faraday/rack_builder.rb, line 128
def insert(index, ...)
  raise_if_locked
  index = assert_index(index)
  handler = self.class::Handler.new(...)
  @handlers.insert(index, handler)
end

Also aliased as: insert_before

insert_after (index, ...)

# File lib/faraday/rack_builder.rb, line 137
def insert_after(index, ...)
  index = assert_index(index)
  insert(index + 1, ...)
end

insert_before (index, ...)

Alias for: insert

lock! ()

Locks the middleware stack to ensure no further modifications are made.

# File lib/faraday/rack_builder.rb, line 92
def lock!
  @handlers.freeze
end

locked? ()

# File lib/faraday/rack_builder.rb, line 96
def locked?
  @handlers.frozen?
end

request (key, ...)

# File lib/faraday/rack_builder.rb, line 110
def request(key, ...)
  use_symbol(Faraday::Request, key, ...)
end

response (...)

# File lib/faraday/rack_builder.rb, line 114
def response(...)
  use_symbol(Faraday::Response, ...)
end

swap (index, ...)

# File lib/faraday/rack_builder.rb, line 142
def swap(index, ...)
  raise_if_locked
  index = assert_index(index)
  @handlers.delete_at(index)
  insert(index, ...)
end

to_app ()

# File lib/faraday/rack_builder.rb, line 180
def to_app
  # last added handler is the deepest and thus closest to the inner app
  # adapter is always the last one
  @handlers.reverse.inject(@adapter.build) do |app, handler|
    handler.build(app)
  end
end

use (klass, ...)

# File lib/faraday/rack_builder.rb, line 100
def use(klass, ...)
  if klass.is_a? Symbol
    use_symbol(Faraday::Middleware, klass, ...)
  else
    raise_if_locked
    raise_if_adapter(klass)
    @handlers << self.class::Handler.new(klass, ...)
  end
end