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://httpbingo.org') 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(&block) ⇒ RackBuilder

Returns a new instance of RackBuilder.



60
61
62
63
64
 
# File 'lib/faraday/rack_builder.rb', line 60

def initialize(&block)
  @adapter = nil
  @handlers = []
  build(&block)
end

Instance Attribute Details

#handlers ⇒ Object

Returns the value of attribute handlers.



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

def handlers
  @handlers
end

Instance Method Details

#==(other) ⇒ Object 



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

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

#[](idx) ⇒ Object 



78
79
80
 
# File 'lib/faraday/rack_builder.rb', line 78

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.



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

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

#build ⇒ Object 



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

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) ⇒ 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.



200
201
202
203
204
205
206
207
208
209
 
# File 'lib/faraday/rack_builder.rb', line 200

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:



151
152
153
 
# File 'lib/faraday/rack_builder.rb', line 151

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

#delete(handler) ⇒ Object 



139
140
141
142
 
# File 'lib/faraday/rack_builder.rb', line 139

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

#initialize_dup(original) ⇒ Object 



66
67
68
69
70
 
# File 'lib/faraday/rack_builder.rb', line 66

def initialize_dup(original)
  super
  @adapter = original.adapter
  @handlers = original.handlers.dup
end

#insert(index) ⇒ Object Also known as: insert_before

methods to push onto the various positions in the stack:



118
119
120
121
122
123
 
# File 'lib/faraday/rack_builder.rb', line 118

def insert(index, ...)
  raise_if_locked
  index = assert_index(index)
  handler = self.class::Handler.new(...)
  @handlers.insert(index, handler)
end

#insert_after(index) ⇒ Object 



127
128
129
130
 
# File 'lib/faraday/rack_builder.rb', line 127

def insert_after(index, ...)
  index = assert_index(index)
  insert(index + 1, ...)
end

#lock! ⇒ Object

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



83
84
85
 
# File 'lib/faraday/rack_builder.rb', line 83

def lock!
  @handlers.freeze
end

#locked? ⇒ Boolean

Returns:

  • (Boolean) 


87
88
89
 
# File 'lib/faraday/rack_builder.rb', line 87

def locked?
  @handlers.frozen?
end

#request(key) ⇒ Object 



101
102
103
 
# File 'lib/faraday/rack_builder.rb', line 101

def request(key, ...)
  use_symbol(Faraday::Request, key, ...)
end

#response ⇒ Object 



105
106
107
 
# File 'lib/faraday/rack_builder.rb', line 105

def response(...)
  use_symbol(Faraday::Response, ...)
end

#swap(index) ⇒ Object 



132
133
134
135
136
137
 
# File 'lib/faraday/rack_builder.rb', line 132

def swap(index, ...)
  raise_if_locked
  index = assert_index(index)
  @handlers.delete_at(index)
  insert(index, ...)
end

#to_app ⇒ Object 



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

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) ⇒ Object 



91
92
93
94
95
96
97
98
99
 
# File 'lib/faraday/rack_builder.rb', line 91

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