Class: Faraday::Connection

Inherits:
Object show all
Includes:
Addressable
Defined in:
lib/faraday/connection.rb

Constant Summary collapse

METHODS = 
Set.new [:get, :post, :put, :delete, :head, :patch, :options]
METHODS_WITH_BODIES = 
Set.new [:post, :put, :patch, :options]

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(url = nil, options = {}) ⇒ Connection

:url :params :headers :request :ssl



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/faraday/connection.rb', line 20

def initialize(url = nil, options = {})
  if url.is_a?(Hash)
    options = url
    url     = options[:url]
  end
  @headers          = Utils::Headers.new
  @params           = Utils::ParamsHash.new
  @options          = options[:request] || {}
  @ssl              = options[:ssl]     || {}
  @parallel_manager = options[:parallel]

  self.url_prefix = url if url
  proxy(options[:proxy])

  @params.update options[:params]   if options[:params]
  @headers.update options[:headers] if options[:headers]

  if block_given?
    @builder = Builder.create { |b| yield b }
  else
    @builder = options[:builder] || Builder.new
  end
end

Instance Attribute Details

#builder ⇒ Object (readonly)

Returns the value of attribute builder.



13
14
15
 
# File 'lib/faraday/connection.rb', line 13

def builder
  @builder
end

#headers ⇒ Object

Returns the value of attribute headers.



12
13
14
 
# File 'lib/faraday/connection.rb', line 12

def headers
  @headers
end

#host ⇒ Object

Returns the value of attribute host.



12
13
14
 
# File 'lib/faraday/connection.rb', line 12

def host
  @host
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



13
14
15
 
# File 'lib/faraday/connection.rb', line 13

def options
  @options
end

#parallel_manager ⇒ Object

Returns the value of attribute parallel_manager.



12
13
14
 
# File 'lib/faraday/connection.rb', line 12

def parallel_manager
  @parallel_manager
end

#params ⇒ Object

Returns the value of attribute params.



12
13
14
 
# File 'lib/faraday/connection.rb', line 12

def params
  @params
end

#path_prefix ⇒ Object

Returns the value of attribute path_prefix.



13
14
15
 
# File 'lib/faraday/connection.rb', line 13

def path_prefix
  @path_prefix
end

#port ⇒ Object

Returns the value of attribute port.



12
13
14
 
# File 'lib/faraday/connection.rb', line 12

def port
  @port
end

#scheme ⇒ Object

Returns the value of attribute scheme.



12
13
14
 
# File 'lib/faraday/connection.rb', line 12

def scheme
  @scheme
end

#ssl ⇒ Object (readonly)

Returns the value of attribute ssl.



13
14
15
 
# File 'lib/faraday/connection.rb', line 13

def ssl
  @ssl
end

Instance Method Details

#adapter(key, *args, &block) ⇒ Object 



56
57
58
 
# File 'lib/faraday/connection.rb', line 56

def adapter(key, *args, &block)
  @builder.adapter(key, *args, &block)
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.



71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/faraday/connection.rb', line 71

def app
  @app ||= begin
    builder.lock!
    builder.to_app(lambda { |env|
      # the inner app that creates and returns the Response object
      response = Response.new
      response.finish(env) unless env[:parallel_manager]
      env[:response] = response
    })
  end
end

#basic_auth(login, pass) ⇒ Object 



113
114
115
116
117
 
# File 'lib/faraday/connection.rb', line 113

def basic_auth(, pass)
  auth = Base64.encode64("#{}:#{pass}")
  auth.gsub!("\n", "")
  @headers['authorization'] = "Basic #{auth}"
end

#build(options = {}, &block) ⇒ Object 



60
61
62
 
# File 'lib/faraday/connection.rb', line 60

def build(options = {}, &block)
  @builder.build(options, &block)
end

#build_url(url, extra_params = nil) ⇒ Object

Takes a relative url for a request and combines it with the defaults set on the connection instance.

conn = Faraday::Connection.new { ... }
conn.url_prefix = "https://sushi.com/api?token=abc"
conn.scheme      # => https
conn.path_prefix # => "/api"

conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2



217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/faraday/connection.rb', line 217

def build_url(url, extra_params = nil)
  uri          = URI.parse(url.to_s)
  if @path_prefix && uri.path !~ /^\//
    uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
  end
  uri.host   ||= @host
  uri.port   ||= @port
  uri.scheme ||= @scheme

  params = @params.dup.merge_query(uri.query)
  params.update extra_params if extra_params
  uri.query = params.empty? ? nil : params.to_query

  uri
end

#delete(url = nil, headers = nil) ⇒ Object 



108
109
110
111
 
# File 'lib/faraday/connection.rb', line 108

def delete(url = nil, headers = nil)
  block = block_given? ? Proc.new : nil
  run_request(:delete, url, nil, headers, &block)
end

#dup ⇒ Object 



233
234
235
 
# File 'lib/faraday/connection.rb', line 233

def dup
  self.class.new(build_url(''), :headers => headers.dup, :params => params.dup, :builder => builder.dup)
end

#get(url = nil, headers = nil) ⇒ Object 



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

def get(url = nil, headers = nil)
  block = block_given? ? Proc.new : nil
  run_request(:get, url, nil, headers, &block)
end

#head(url = nil, headers = nil) ⇒ Object 



103
104
105
106
 
# File 'lib/faraday/connection.rb', line 103

def head(url = nil, headers = nil)
  block = block_given? ? Proc.new : nil
  run_request(:head, url, nil, headers, &block)
end

#in_parallel(manager) ⇒ Object 



133
134
135
136
137
138
139
 
# File 'lib/faraday/connection.rb', line 133

def in_parallel(manager)
  @parallel_manager = manager
  yield
  @parallel_manager && @parallel_manager.run
ensure
  @parallel_manager = nil
end

#in_parallel? ⇒ Boolean

Returns:

  • (Boolean) 


129
130
131
 
# File 'lib/faraday/connection.rb', line 129

def in_parallel?
  !!@parallel_manager
end

#patch(url = nil, body = nil, headers = nil) ⇒ Object 



98
99
100
101
 
# File 'lib/faraday/connection.rb', line 98

def patch(url = nil, body = nil, headers = nil)
  block = block_given? ? Proc.new : nil
  run_request(:patch, url, body, headers, &block)
end

#post(url = nil, body = nil, headers = nil) ⇒ Object 



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

def post(url = nil, body = nil, headers = nil)
  block = block_given? ? Proc.new : nil
  run_request(:post, url, body, headers, &block)
end

#proxy(arg = nil) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/faraday/connection.rb', line 141

def proxy(arg = nil)
  return @proxy if arg.nil?

  @proxy =
    case arg
      when String then {:uri => proxy_arg_to_uri(arg)}
      when URI    then {:uri => arg}
      when Hash
        if arg[:uri] = proxy_arg_to_uri(arg[:uri])
          arg
        else
          raise ArgumentError, "no :uri option."
        end
    end
end

#proxy_arg_to_uri(arg) ⇒ Object 



237
238
239
240
241
242
 
# File 'lib/faraday/connection.rb', line 237

def proxy_arg_to_uri(arg)
  case arg
    when String then URI.parse(arg)
    when URI    then arg
  end
end

#put(url = nil, body = nil, headers = nil) ⇒ Object 



93
94
95
96
 
# File 'lib/faraday/connection.rb', line 93

def put(url = nil, body = nil, headers = nil)
  block = block_given? ? Proc.new : nil
  run_request(:put, url, body, headers, &block)
end

#request(key, *args, &block) ⇒ Object 



48
49
50
 
# File 'lib/faraday/connection.rb', line 48

def request(key, *args, &block)
  @builder.request(key, *args, &block)
end

#response(key, *args, &block) ⇒ Object 



52
53
54
 
# File 'lib/faraday/connection.rb', line 52

def response(key, *args, &block)
  @builder.response(key, *args, &block)
end

#run_request(method, url, body, headers) ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/faraday/connection.rb', line 190

def run_request(method, url, body, headers)
  if !METHODS.include?(method)
    raise ArgumentError, "unknown http method: #{method}"
  end

  request = Request.create(method) do |req|
    req.url(url)                if url
    req.headers.update(headers) if headers
    req.body = body             if body
    yield req if block_given?
  end

  env = request.to_env(self)
  self.app.call(env)
end

#token_auth(token, options = {}) ⇒ Object 



119
120
121
122
123
124
125
126
127
 
# File 'lib/faraday/connection.rb', line 119

def token_auth(token, options = {})
  values = ["token=#{token.to_s.inspect}"]
  options.each do |key, value|
    values << "#{key}=#{value.to_s.inspect}"
  end
  # 21 = "Authorization: Token ".size
  comma = ",\n#{' ' * 21}"
  @headers['authorization'] = "Token #{values * comma}"
end

#url_prefix=(url) ⇒ Object

Parses the giving url with Addressable::URI and stores the individual components in this connection. These components serve as defaults for requests made by this connection.

conn = Faraday::Connection.new { ... }
conn.url_prefix = "https://sushi.com/api"
conn.scheme      # => https
conn.path_prefix # => "/api"

conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri



168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/faraday/connection.rb', line 168

def url_prefix=(url)
  uri              = URI.parse(url)
  self.scheme      = uri.scheme
  self.host        = uri.host
  self.port        = uri.port
  self.path_prefix = uri.path

  @params.merge_query(uri.query)
  basic_auth(uri.user, uri.password) if uri.user && uri.password

  uri
end

#use(klass, *args, &block) ⇒ Object 



44
45
46
 
# File 'lib/faraday/connection.rb', line 44

def use(klass, *args, &block)
  @builder.use(klass, *args, &block)
end