-
Notifications
You must be signed in to change notification settings - Fork 968
/
httparty.rb
459 lines (406 loc) · 14.1 KB
/
httparty.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
require 'pathname'
require 'net/http'
require 'net/https'
require 'uri'
require 'zlib'
require 'crack'
dir = Pathname(__FILE__).dirname.expand_path
require dir + 'httparty/module_inheritable_attributes'
require dir + 'httparty/cookie_hash'
require dir + 'httparty/net_digest_auth'
# @see HTTParty::ClassMethods
module HTTParty
VERSION = "0.7.0".freeze
CRACK_DEPENDENCY = "0.1.8".freeze
module AllowedFormatsDeprecation
def const_missing(const)
if const.to_s =~ /AllowedFormats$/
Kernel.warn("Deprecated: Use HTTParty::Parser::SupportedFormats")
HTTParty::Parser::SupportedFormats
else
super
end
end
end
extend AllowedFormatsDeprecation
def self.included(base)
base.extend ClassMethods
base.send :include, HTTParty::ModuleInheritableAttributes
base.send(:mattr_inheritable, :default_options)
base.send(:mattr_inheritable, :default_cookies)
base.instance_variable_set("@default_options", {})
base.instance_variable_set("@default_cookies", CookieHash.new)
end
# == Common Request Options
# Request methods (get, post, put, delete, head, options) all take a common set of options. These are:
#
# [:+body+:] Body of the request. If passed a Hash, will try to normalize it first, by default passing it to ActiveSupport::to_params. Any other kind of object will get used as-is.
# [:+http_proxyaddr+:] Address of proxy server to use.
# [:+http_proxyport+:] Port of proxy server to use.
# [:+limit+:] Maximum number of redirects to follow. Takes precedences over :+no_follow+.
# [:+query+:] Query string, or a Hash representing it. Normalized according to the same rules as :+body+. If you specify this on a POST, you must use a Hash. See also HTTParty::ClassMethods.default_params.
# [:+timeout+:] Timeout for opening connection and reading data.
#
# There are also another set of options with names corresponding to various class methods. The methods in question are those that let you set a class-wide default, and the options override the defaults on a request-by-request basis. Those options are:
# * :+base_uri+: see HTTParty::ClassMethods.base_uri.
# * :+basic_auth+: see HTTParty::ClassMethods.basic_auth. Only one of :+basic_auth+ and :+digest_auth+ can be used at a time; if you try using both, you'll get an ArgumentError.
# * :+debug_output+: see HTTParty::ClassMethods.debug_output.
# * :+digest_auth+: see HTTParty::ClassMethods.digest_auth. Only one of :+basic_auth+ and :+digest_auth+ can be used at a time; if you try using both, you'll get an ArgumentError.
# * :+format+: see HTTParty::ClassMethods.format.
# * :+headers+: see HTTParty::ClassMethods.headers. Must be a Hash.
# * :+maintain_method_across_redirects+: see HTTParty::ClassMethods.maintain_method_across_redirects.
# * :+no_follow+: see HTTParty::ClassMethods.no_follow.
# * :+parser+: see HTTParty::ClassMethods.parser.
# * :+pem+: see HTTParty::ClassMethods.pem.
# * :+query_string_normalizer+: see HTTParty::ClassMethods.query_string_normalizer
# * :+ssl_ca_file+: see HTTParty::ClassMethods.ssl_ca_file.
module ClassMethods
extend AllowedFormatsDeprecation
# Allows setting http proxy information to be used
#
# class Foo
# include HTTParty
# http_proxy 'http://foo.com', 80
# end
def http_proxy(addr=nil, port = nil)
default_options[:http_proxyaddr] = addr
default_options[:http_proxyport] = port
end
# Allows setting a base uri to be used for each request.
# Will normalize uri to include http, etc.
#
# class Foo
# include HTTParty
# base_uri 'twitter.com'
# end
def base_uri(uri=nil)
return default_options[:base_uri] unless uri
default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
end
# Allows setting basic authentication username and password.
#
# class Foo
# include HTTParty
# basic_auth 'username', 'password'
# end
def basic_auth(u, p)
default_options[:basic_auth] = {:username => u, :password => p}
end
# Allows setting digest authentication username and password.
#
# class Foo
# include HTTParty
# digest_auth 'username', 'password'
# end
def digest_auth(u, p)
default_options[:digest_auth] = {:username => u, :password => p}
end
# Do not send rails style query strings.
# Specically, don't use bracket notation when sending an array
#
# For a query:
# get '/', :query => {:selected_ids => [1,2,3]}
#
# The default query string looks like this:
# /?selected_ids[]=1&selected_ids[]=2&selected_ids[]=3
#
# Call `disable_rails_query_string_format` to transform the query string
# into:
# /?selected_ids=1&selected_ids=2&selected_ids=3
#
# @example
# class Foo
# include HTTParty
# disable_rails_query_string_format
# end
def disable_rails_query_string_format
query_string_normalizer Request::NON_RAILS_QUERY_STRING_NORMALIZER
end
# Allows setting default parameters to be appended to each request.
# Great for api keys and such.
#
# class Foo
# include HTTParty
# default_params :api_key => 'secret', :another => 'foo'
# end
def default_params(h={})
raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
default_options[:default_params] ||= {}
default_options[:default_params].merge!(h)
end
# Allows setting a default timeout for all HTTP calls
# Timeout is specified in seconds.
#
# class Foo
# include HTTParty
# default_timeout 10
# end
def default_timeout(t)
raise ArgumentError, 'Timeout must be an integer' unless t && t.is_a?(Integer)
default_options[:timeout] = t
end
# Set an output stream for debugging, defaults to $stderr.
# The output stream is passed on to Net::HTTP#set_debug_output.
#
# class Foo
# include HTTParty
# debug_output $stderr
# end
def debug_output(stream = $stderr)
default_options[:debug_output] = stream
end
# Allows setting HTTP headers to be used for each request.
#
# class Foo
# include HTTParty
# headers 'Accept' => 'text/html'
# end
def headers(h={})
raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
default_options[:headers] ||= {}
default_options[:headers].merge!(h)
end
def cookies(h={})
raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
default_cookies.add_cookies(h)
end
# Proceed to the location header when an HTTP response dictates a redirect.
# Redirects are always followed by default.
#
# @example
# class Foo
# include HTTParty
# base_uri 'http://google.com'
# follow_redirects true
# end
def follow_redirects(value = true)
default_options[:follow_redirects] = value
end
# Allows setting the format with which to parse.
# Must be one of the allowed formats ie: json, xml
#
# class Foo
# include HTTParty
# format :json
# end
def format(f = nil)
if f.nil?
default_options[:format]
else
parser(Parser) if parser.nil?
default_options[:format] = f
validate_format
end
end
# Declare whether or not to follow redirects. When true, an
# {HTTParty::RedirectionTooDeep} error will raise upon encountering a
# redirect. You can then gain access to the response object via
# HTTParty::RedirectionTooDeep#response.
#
# @see HTTParty::ResponseError#response
#
# @example
# class Foo
# include HTTParty
# base_uri 'http://google.com'
# no_follow true
# end
#
# begin
# Foo.get('/')
# rescue HTTParty::RedirectionTooDeep => e
# puts e.response.body
# end
def no_follow(value = false)
default_options[:no_follow] = value
end
# Declare that you wish to maintain the chosen HTTP method across redirects.
# The default behavior is to follow redirects via the GET method.
# If you wish to maintain the original method, you can set this option to true.
#
# @example
# class Foo
# include HTTParty
# base_uri 'http://google.com'
# maintain_method_across_redirects true
# end
def maintain_method_across_redirects(value = true)
default_options[:maintain_method_across_redirects] = value
end
# Allows setting a PEM file to be used
#
# class Foo
# include HTTParty
# pem File.read('/home/user/my.pem'), "optional password"
# end
def pem(pem_contents, password=nil)
default_options[:pem] = pem_contents
default_options[:pem_password] = password
end
# Override the way query strings are normalized.
# Helpful for overriding the default rails normalization of Array queries.
#
# For a query:
# get '/', :query => {:selected_ids => [1,2,3]}
#
# The default query string normalizer returns:
# /?selected_ids[]=1&selected_ids[]=2&selected_ids[]=3
#
# Let's change it to this:
# /?selected_ids=1&selected_ids=2&selected_ids=3
#
# Pass a Proc to the query normalizer which accepts the yielded query.
#
# @example Modifying Array query strings
# class ServiceWrapper
# include HTTParty
#
# query_string_normalizer proc { |query|
# query.map do |key, value|
# value.map {|v| "#{key}=#{v}"}
# end.join('&')
# }
# end
#
# @param [Proc] normalizer custom query string normalizer.
# @yield [Hash, String] query string
# @yieldreturn [Array] an array that will later be joined with '&'
def query_string_normalizer(normalizer)
default_options[:query_string_normalizer] = normalizer
end
# Allows setting an OpenSSL certificate authority file
#
# class Foo
# include HTTParty
# ssl_ca_file '/etc/ssl/certs/ca-certificates.crt'
# end
def ssl_ca_file(path)
default_options[:ssl_ca_file] = path
end
# Allows setting an OpenSSL certificate authority path (directory)
#
# class Foo
# include HTTParty
# ssl_ca_path '/etc/ssl/certs/'
# end
def ssl_ca_path(path)
default_options[:ssl_ca_path] = path
end
# Allows setting a custom parser for the response.
#
# class Foo
# include HTTParty
# parser Proc.new {|data| ...}
# end
def parser(custom_parser = nil)
if custom_parser.nil?
default_options[:parser]
else
default_options[:parser] = custom_parser
validate_format
end
end
# Allows making a get request to a url.
#
# class Foo
# include HTTParty
# end
#
# # Simple get with full url
# Foo.get('http://foo.com/resource.json')
#
# # Simple get with full url and query parameters
# # ie: http://foo.com/resource.json?limit=10
# Foo.get('http://foo.com/resource.json', :query => {:limit => 10})
def get(path, options={})
perform_request Net::HTTP::Get, path, options
end
# Allows making a post request to a url.
#
# class Foo
# include HTTParty
# end
#
# # Simple post with full url and setting the body
# Foo.post('http://foo.com/resources', :body => {:bar => 'baz'})
#
# # Simple post with full url using :query option,
# # which gets set as form data on the request.
# Foo.post('http://foo.com/resources', :query => {:bar => 'baz'})
def post(path, options={})
perform_request Net::HTTP::Post, path, options
end
# Perform a PUT request to a path
def put(path, options={})
perform_request Net::HTTP::Put, path, options
end
# Perform a DELETE request to a path
def delete(path, options={})
perform_request Net::HTTP::Delete, path, options
end
# Perform a HEAD request to a path
def head(path, options={})
perform_request Net::HTTP::Head, path, options
end
# Perform an OPTIONS request to a path
def options(path, options={})
perform_request Net::HTTP::Options, path, options
end
def default_options #:nodoc:
@default_options
end
private
def perform_request(http_method, path, options) #:nodoc:
options = default_options.dup.merge(options)
process_cookies(options)
Request.new(http_method, path, options).perform
end
def process_cookies(options) #:nodoc:
return unless options[:cookies] || default_cookies.any?
options[:headers] ||= headers.dup
options[:headers]["cookie"] = cookies.merge(options.delete(:cookies) || {}).to_cookie_string
end
def validate_format
if format && parser.respond_to?(:supports_format?) && !parser.supports_format?(format)
raise UnsupportedFormat, "'#{format.inspect}' Must be one of: #{parser.supported_formats.map{|f| f.to_s}.sort.join(', ')}"
end
end
end
def self.normalize_base_uri(url) #:nodoc:
normalized_url = url.dup
use_ssl = (normalized_url =~ /^https/) || normalized_url.include?(':443')
ends_with_slash = normalized_url =~ /\/$/
normalized_url.chop! if ends_with_slash
normalized_url.gsub!(/^https?:\/\//i, '')
"http#{'s' if use_ssl}://#{normalized_url}"
end
class Basement #:nodoc:
include HTTParty
end
def self.get(*args)
Basement.get(*args)
end
def self.post(*args)
Basement.post(*args)
end
def self.put(*args)
Basement.put(*args)
end
def self.delete(*args)
Basement.delete(*args)
end
def self.head(*args)
Basement.head(*args)
end
def self.options(*args)
Basement.options(*args)
end
end
require dir + 'httparty/core_extensions'
require dir + 'httparty/exceptions'
require dir + 'httparty/parser'
require dir + 'httparty/request'
require dir + 'httparty/response'
if Crack::VERSION != HTTParty::CRACK_DEPENDENCY
warn "warning: HTTParty depends on version #{HTTParty::CRACK_DEPENDENCY} of crack, not #{Crack::VERSION}."
end