base_uri(uri=nil)
click to toggle source
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
basic_auth(u, p)
click to toggle source
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
cookies(h={})
click to toggle source
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)
click to toggle source
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
default_params(h={})
click to toggle source
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
default_timeout(t)
click to toggle source
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 or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
default_options[:timeout] = t
end
delete(path, options={}, &block)
click to toggle source
Perform a DELETE request to a path
def delete(path, options={}, &block)
perform_request Net::HTTP::Delete, path, options, &block
end
digest_auth(u, p)
click to toggle source
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
follow_redirects(value = true)
click to toggle source
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
get(path, options={}, &block)
click to toggle source
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={}, &block)
perform_request Net::HTTP::Get, path, options, &block
end
head(path, options={}, &block)
click to toggle source
Perform a HEAD request to a path
def head(path, options={}, &block)
perform_request Net::HTTP::Head, path, options, &block
end
http_proxy(addr=nil, port=nil, user=nil, pass=nil)
click to toggle source
Allows setting http proxy information to be used
class Foo
include HTTParty
http_proxy 'http://foo.com', 80, 'user', 'pass'
end
def http_proxy(addr=nil, port=nil, user=nil, pass=nil)
default_options[:http_proxyaddr] = addr
default_options[:http_proxyport] = port
default_options[:http_proxyuser] = user
default_options[:http_proxypass] = pass
end
maintain_method_across_redirects(value = true)
click to toggle source
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
no_follow(value = false)
click to toggle source
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
options(path, options={}, &block)
click to toggle source
Perform an OPTIONS request to a path
def options(path, options={}, &block)
perform_request Net::HTTP::Options, path, options, &block
end
parser(custom_parser = nil)
click to toggle source
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
patch(path, options={}, &block)
click to toggle source
Perform a PATCH request to a path
def patch(path, options={}, &block)
perform_request Net::HTTP::Patch, path, options, &block
end
pem(pem_contents, password=nil)
click to toggle source
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
post(path, options={}, &block)
click to toggle source
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={}, &block)
perform_request Net::HTTP::Post, path, options, &block
end
put(path, options={}, &block)
click to toggle source
Perform a PUT request to a path
def put(path, options={}, &block)
perform_request Net::HTTP::Put, path, options, &block
end
query_string_normalizer(normalizer)
click to toggle source
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
ssl_ca_file(path)
click to toggle source
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
ssl_ca_path(path)
click to toggle source
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