Module: HTTParty::ClassMethods

Extended by:
AllowedFormatsDeprecation
Defined in:
lib/httparty.rb

Instance Method Summary collapse

Methods included from AllowedFormatsDeprecation

const_missing

Instance Method Details

#base_uri(uri = nil) ⇒ Object

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



61
62
63
64
 
# File 'lib/httparty.rb', line 61

def base_uri(uri=nil)
  return default_options[:base_uri] unless uri
  default_options[:base_uri] = HTTParty.normalize_base_uri(uri)
end

#basic_auth(u, p) ⇒ Object

Allows setting basic authentication username and password.

class Foo
  include HTTParty
  basic_auth 'username', 'password'
end



72
73
74
 
# File 'lib/httparty.rb', line 72

def basic_auth(u, p)
  default_options[:basic_auth] = {:username => u, :password => p}
end

#cookies(h = {}) ⇒ Object

Raises:

  • (ArgumentError) 


134
135
136
137
 
# File 'lib/httparty.rb', line 134

def cookies(h={})
  raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
  default_cookies.add_cookies(h)
end

#debug_output(stream = $stderr) ⇒ Object

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



118
119
120
 
# File 'lib/httparty.rb', line 118

def debug_output(stream = $stderr)
  default_options[:debug_output] = stream
end

#default_options ⇒ Object

:nodoc:



291
292
293
 
# File 'lib/httparty.rb', line 291

def default_options #:nodoc:
  @default_options
end

#default_params(h = {}) ⇒ Object

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

Raises:

  • (ArgumentError) 


93
94
95
96
97
 
# File 'lib/httparty.rb', line 93

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

#default_timeout(t) ⇒ Object

Allows setting a default timeout for all HTTP calls Timeout is specified in seconds.

class Foo
  include HTTParty
  default_timeout 10
end

Raises:

  • (ArgumentError) 


106
107
108
109
 
# File 'lib/httparty.rb', line 106

def default_timeout(t)
  raise ArgumentError, 'Timeout must be an integer' unless t && t.is_a?(Integer)
  default_options[:timeout] = t
end

#delete(path, options = {}) ⇒ Object

Perform a DELETE request to a path



277
278
279
 
# File 'lib/httparty.rb', line 277

def delete(path, options={})
  perform_request Net::HTTP::Delete, path, options
end

#digest_auth(u, p) ⇒ Object

Allows setting digest authentication username and password.

class Foo
  include HTTParty
  digest_auth 'username', 'password'
end



82
83
84
 
# File 'lib/httparty.rb', line 82

def digest_auth(u, p)
  default_options[:digest_auth] = {:username => u, :password => p}
end

#format(f = nil) ⇒ Object

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



146
147
148
149
150
151
152
153
154
 
# File 'lib/httparty.rb', line 146

def format(f = nil)
  if f.nil?
    default_options[:format]
  else
    parser(Parser) if parser.nil?
    default_options[:format] = f
    validate_format
  end
end

#get(path, options = {}) ⇒ Object

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})



251
252
253
 
# File 'lib/httparty.rb', line 251

def get(path, options={})
  perform_request Net::HTTP::Get, path, options
end

#head(path, options = {}) ⇒ Object

Perform a HEAD request to a path



282
283
284
 
# File 'lib/httparty.rb', line 282

def head(path, options={})
  perform_request Net::HTTP::Head, path, options
end

#headers(h = {}) ⇒ Object

Allows setting HTTP headers to be used for each request.

class Foo
  include HTTParty
  headers 'Accept' => 'text/html'
end

Raises:

  • (ArgumentError) 


128
129
130
131
132
 
# File 'lib/httparty.rb', line 128

def headers(h={})
  raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
  default_options[:headers] ||= {}
  default_options[:headers].merge!(h)
end

#http_proxy(addr = nil, port = nil) ⇒ Object

Allows setting http proxy information to be used

class Foo
  include HTTParty
  http_proxy 'http://foo.com', 80
end



49
50
51
52
 
# File 'lib/httparty.rb', line 49

def http_proxy(addr=nil, port = nil)
  default_options[:http_proxyaddr] = addr
  default_options[:http_proxyport] = port
end

#maintain_method_across_redirects(value = true) ⇒ Object

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.

Examples:

class Foo
  include HTTParty
  base_uri 'http://google.com'
  maintain_method_across_redirects true
end


190
191
192
 
# File 'lib/httparty.rb', line 190

def maintain_method_across_redirects(value = true)
  default_options[:maintain_method_across_redirects] = value
end

#no_follow(value = false) ⇒ Object

Declare whether or not to follow redirects. When true, an RedirectionTooDeep error will raise upon encountering a redirect. You can then gain access to the response object via HTTParty::RedirectionTooDeep#response.

Examples:

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

See Also:



175
176
177
 
# File 'lib/httparty.rb', line 175

def no_follow(value = false)
  default_options[:no_follow] = value
end

#options(path, options = {}) ⇒ Object

Perform an OPTIONS request to a path



287
288
289
 
# File 'lib/httparty.rb', line 287

def options(path, options={})
  perform_request Net::HTTP::Options, path, options
end

#parser(custom_parser = nil) ⇒ Object

Allows setting a custom parser for the response.

class Foo
  include HTTParty
  parser Proc.new {|data| ...}
end



230
231
232
233
234
235
236
237
 
# File 'lib/httparty.rb', line 230

def parser(custom_parser = nil)
  if custom_parser.nil?
    default_options[:parser]
  else
    default_options[:parser] = custom_parser
    validate_format
  end
end

#pem(pem_contents) ⇒ Object

Allows setting a PEM file to be used

class Foo
  include HTTParty
  pem File.read('/home/user/my.pem')
end



200
201
202
 
# File 'lib/httparty.rb', line 200

def pem(pem_contents)
  default_options[:pem] = pem_contents
end

#post(path, options = {}) ⇒ Object

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'})



267
268
269
 
# File 'lib/httparty.rb', line 267

def post(path, options={})
  perform_request Net::HTTP::Post, path, options
end

#put(path, options = {}) ⇒ Object

Perform a PUT request to a path



272
273
274
 
# File 'lib/httparty.rb', line 272

def put(path, options={})
  perform_request Net::HTTP::Put, path, options
end

#ssl_ca_file(path) ⇒ Object

Allows setting an OpenSSL certificate authority file

class Foo
  include HTTParty
  ssl_ca_file '/etc/ssl/certs/ca-certificates.crt'
end



210
211
212
 
# File 'lib/httparty.rb', line 210

def ssl_ca_file(path)
  default_options[:ssl_ca_file] = path
end

#ssl_ca_path(path) ⇒ Object

Allows setting an OpenSSL certificate authority path (directory)

class Foo
  include HTTParty
  ssl_ca_path '/etc/ssl/certs/'
end



220
221
222
 
# File 'lib/httparty.rb', line 220

def ssl_ca_path(path)
  default_options[:ssl_ca_path] = path
end