Class: Faraday::RackBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/faraday/rack_builder.rb

Overview

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

Examples:

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

Defined Under Namespace

Classes: Handler, StackLocked

Constant Summary collapse

NO_ARGUMENT =

Used to detect missing arguments

Object.new

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(handlers = [], adapter = nil, &block) ⇒ RackBuilder

Returns a new instance of RackBuilder.



61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/faraday/rack_builder.rb', line 61

def initialize(handlers = [], adapter = nil, &block)
  @adapter = adapter
  @handlers = handlers
  if block_given?
    build(&block)
  elsif @handlers.empty?
    # default stack, if nothing else is configured
    request :url_encoded
    self.adapter Faraday.default_adapter
  end
end

Instance Attribute Details

#handlers ⇒ Object

Returns the value of attribute handlers.



19
20
21
 
# File 'lib/faraday/rack_builder.rb', line 19

def handlers
  @handlers
end

Instance Method Details

#==(other) ⇒ Object 



179
180
181
182
183
 
# File 'lib/faraday/rack_builder.rb', line 179

def ==(other)
  other.is_a?(self.class) &&
    @handlers == other.handlers &&
    @adapter == other.adapter
end

#[](idx) ⇒ Object 



80
81
82
 
# File 'lib/faraday/rack_builder.rb', line 80

def [](idx)
  @handlers[idx]
end

#app ⇒ Object

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.



164
165
166
167
168
169
 
# File 'lib/faraday/rack_builder.rb', line 164

def app
  @app ||= begin
    lock!
    to_app
  end
end

#build(options = {}) {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:



73
74
75
76
77
78
 
# File 'lib/faraday/rack_builder.rb', line 73

def build(options = {})
  raise_if_locked
  @handlers.clear unless options[:keep]
  yield(self) if block_given?
  adapter(Faraday.default_adapter) unless @adapter
end

#build_env(connection, request) ⇒ Object

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.



205
206
207
208
209
210
211
212
213
214
 
# File 'lib/faraday/rack_builder.rb', line 205

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) ⇒ Faraday::Response

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

Parameters:

Returns:



153
154
155
 
# File 'lib/faraday/rack_builder.rb', line 153

def build_response(connection, request)
  app.call(build_env(connection, request))
end

#delete(handler) ⇒ Object 



141
142
143
144
 
# File 'lib/faraday/rack_builder.rb', line 141

def delete(handler)
  raise_if_locked
  @handlers.delete(handler)
end

#dup ⇒ Object 



185
186
187
 
# File 'lib/faraday/rack_builder.rb', line 185

def dup
  self.class.new(@handlers.dup, @adapter.dup)
end

#insert ⇒ Object Also known as: insert_before

methods to push onto the various positions in the stack:



120
121
122
123
124
125
 
# File 'lib/faraday/rack_builder.rb', line 120

ruby2_keywords def insert(index, *args, &block)
  raise_if_locked
  index = assert_index(index)
  handler = self.class::Handler.new(*args, &block)
  @handlers.insert(index, handler)
end

#lock! ⇒ Object

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



85
86
87
 
# File 'lib/faraday/rack_builder.rb', line 85

def lock!
  @handlers.freeze
end

#locked? ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/faraday/rack_builder.rb', line 89

def locked?
  @handlers.frozen?
end

#to_app ⇒ Object 



171
172
173
174
175
176
177
 
# File 'lib/faraday/rack_builder.rb', line 171

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