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



64
65
66
67
 
# File 'lib/httparty.rb', line 64

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



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

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

#cookies(h = {}) ⇒ Object

Raises:

  • (ArgumentError) 


137
138
139
140
 
# File 'lib/httparty.rb', line 137

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



121
122
123
 
# File 'lib/httparty.rb', line 121

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

#default_options ⇒ Object

:nodoc:



309
310
311
 
# File 'lib/httparty.rb', line 309

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) 


96
97
98
99
100
 
# File 'lib/httparty.rb', line 96

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) 


109
110
111
112
 
# File 'lib/httparty.rb', line 109

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



295
296
297
 
# File 'lib/httparty.rb', line 295

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



85
86
87
 
# File 'lib/httparty.rb', line 85

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



149
150
151
152
153
154
155
156
157
 
# File 'lib/httparty.rb', line 149

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



254
255
256
 
# File 'lib/httparty.rb', line 254

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

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

Perform a HEAD request to a path



300
301
302
 
# File 'lib/httparty.rb', line 300

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) 


131
132
133
134
135
 
# File 'lib/httparty.rb', line 131

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



52
53
54
55
 
# File 'lib/httparty.rb', line 52

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


193
194
195
 
# File 'lib/httparty.rb', line 193

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:



178
179
180
 
# File 'lib/httparty.rb', line 178

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

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

Perform an OPTIONS request to a path



305
306
307
 
# File 'lib/httparty.rb', line 305

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



233
234
235
236
237
238
239
240
 
# File 'lib/httparty.rb', line 233

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



203
204
205
 
# File 'lib/httparty.rb', line 203

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

Posting a few files as multipart:

Foo.post('http://foo.com/resources',
         :multipart => {
           'file' => {
             :path => '/tmp/foo.txt',
             :type => 'text/plain'
           },
           'file2' => {
             :path => '/tmp/foo2.txt',
             :type => 'text/plain'
           }
         }
       )



284
285
286
287
 
# File 'lib/httparty.rb', line 284

def post(path, options={})
  klass = options[:multipart] ? Net::HTTP::Post::Multipart : Net::HTTP::Post
  perform_request klass, path, options
end

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

Perform a PUT request to a path



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

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



213
214
215
 
# File 'lib/httparty.rb', line 213

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



223
224
225
 
# File 'lib/httparty.rb', line 223

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