Class: Faraday::Connection

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

Constant Summary collapse

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

Constants included from Utils

Utils::HEADERS

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Utils

#escape, #merge_headers, #merge_params, #normalize_path

Constructor Details

#initialize(url = nil, options = {}, &block) ⇒ 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
# File 'lib/faraday/connection.rb', line 20

def initialize(url = nil, options = {}, &block)
  if url.is_a?(Hash)
    options = url
    url     = options[:url]
  end
  @headers          = HeaderHash.new
  @params           = {}
  @options          = options[:request] || {}
  @ssl              = options[:ssl]     || {}
  @parallel_manager = options[:parallel]
  self.url_prefix = url if url
  proxy(options[:proxy])
  merge_params  @params,  options[:params]  if options[:params]
  merge_headers @headers, options[:headers] if options[:headers]

  if block
    @builder = Builder.new
    @builder.build { block.call(self) }
  else
    @builder = options[:builder] || Builder.new
  end
end

Instance Attribute Details

#builderObject (readonly)

Returns the value of attribute builder



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

def builder
  @builder
end

#headersObject

Returns the value of attribute headers



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

def headers
  @headers
end

#hostObject

Returns the value of attribute host



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

def host
  @host
end

#optionsObject (readonly)

Returns the value of attribute options



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

def options
  @options
end

#parallel_managerObject

Returns the value of attribute parallel_manager



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

def parallel_manager
  @parallel_manager
end

#paramsObject

Returns the value of attribute params



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

def params
  @params
end

#path_prefixObject

Returns the value of attribute path_prefix



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

def path_prefix
  @path_prefix
end

#portObject

Returns the value of attribute port



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

def port
  @port
end

#schemeObject

Returns the value of attribute scheme



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

def scheme
  @scheme
end

#sslObject (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



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

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

#basic_auth(login, pass) ⇒ Object



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

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

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



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

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

#build_url(url, 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


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

def build_url(url, 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
  replace_query(uri, params)
  uri
end

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



79
80
81
# File 'lib/faraday/connection.rb', line 79

def delete(url = nil, headers = nil, &block)
  run_request(:delete, url, nil, headers, &block)
end

#dupObject



202
203
204
# File 'lib/faraday/connection.rb', line 202

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

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



63
64
65
# File 'lib/faraday/connection.rb', line 63

def get(url = nil, headers = nil, &block)
  run_request(:get, url, nil, headers, &block)
end

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



75
76
77
# File 'lib/faraday/connection.rb', line 75

def head(url = nil, headers = nil, &block)
  run_request(:head, url, nil, headers, &block)
end

#in_parallel(manager) ⇒ Object



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

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

#in_parallel?Boolean

Returns:

  • (Boolean)


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

def in_parallel?
  !!@parallel_manager
end

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



67
68
69
# File 'lib/faraday/connection.rb', line 67

def post(url = nil, body = nil, headers = nil, &block)
  run_request(:post, url, body, headers, &block)
end

#proxy(arg = nil) ⇒ Object



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
# File 'lib/faraday/connection.rb', line 111

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   then arg
        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



218
219
220
221
222
223
# File 'lib/faraday/connection.rb', line 218

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, &block) ⇒ Object



71
72
73
# File 'lib/faraday/connection.rb', line 71

def put(url = nil, body = nil, headers = nil, &block)
  run_request(:put, url, body, headers, &block)
end

#replace_query(uri, params) ⇒ Object



206
207
208
209
210
211
212
213
214
215
216
# File 'lib/faraday/connection.rb', line 206

def replace_query(uri, params)
  url_params = @params.dup
  if uri.query && !uri.query.empty?
    merge_params(url_params, parse_query(uri.query))
  end
  if params && !params.empty?
    merge_params(url_params, params)
  end
  uri.query = url_params.empty? ? nil : build_query(url_params)
  uri
end

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



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

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

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



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

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

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



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

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

  Request.run(self, 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
end

#to_appObject

return the assembled Rack application for this instance.



162
163
164
# File 'lib/faraday/connection.rb', line 162

def to_app
  @builder.to_app
end

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



89
90
91
92
93
94
95
96
97
# File 'lib/faraday/connection.rb', line 89

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


138
139
140
141
142
143
144
145
146
147
148
149
150
# File 'lib/faraday/connection.rb', line 138

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
  if uri.query && !uri.query.empty?
    merge_params @params, parse_query(uri.query)
  end
  if uri.user && uri.password
    basic_auth(uri.user, uri.password)
  end
end

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



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

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