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
ciphers(cipher_names)
click to toggle source
Allows setting of SSL ciphers to use. This only works in Ruby 1.9+. You
can get a list of valid specific ciphers from OpenSSL::Cipher.ciphers. You
also can specify a cipher suite here, listed here at openssl.org: www.openssl.org/docs/apps/ciphers.html#CIPHER_SUITE_NAMES
class Foo
include HTTParty
ciphers "RC4-SHA"
end
def ciphers(cipher_names)
default_options[:ciphers] = cipher_names
end
connection_adapter(custom_adapter = nil, options = nil)
click to toggle source
Allows setting a custom connection_adapter
for the http connections
@example
class Foo
include HTTParty
connection_adapter Proc.new {|uri, options| ... }
end
@example provide optional configuration for your connection_adapter
class Foo
include HTTParty
connection_adapter Proc.new {|uri, options| ... }, {:foo => :bar}
end
@see HTTParty::ConnectionAdapter
def connection_adapter(custom_adapter = nil, options = nil)
if custom_adapter.nil?
default_options[:connection_adapter]
else
default_options[:connection_adapter] = custom_adapter
default_options[:connection_adapter_options] = options
end
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
copy(path, options={}, &block)
click to toggle source
Perform a COPY request to a path
def copy(path, options={}, &block)
perform_request Net::HTTP::Copy, path, options, &block
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
logger(logger, level=:info, format=:apache)
click to toggle source
Turns on logging
class Foo
include HTTParty
logger Logger.new('http_logger'), :info, :apache
end
def logger(logger, level=:info, format=:apache)
default_options[:logger] = logger
default_options[:log_level] = level
default_options[:log_format] = format
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
move(path, options={}, &block)
click to toggle source
Perform a MOVE request to a path
def move(path, options={}, &block)
perform_request Net::HTTP::Move, path, options, &block
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
open_timeout(t)
click to toggle source
Allows setting a default open_timeout for all
HTTP calls in seconds
class Foo
include HTTParty
open_timeout 10
end
def open_timeout(t)
raise ArgumentError, 'open_timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
default_options[:open_timeout] = t
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
pkcs12(p12_contents, password)
click to toggle source
Allows setting a PKCS12 file to be used
class Foo
include HTTParty
pkcs12 File.read('/home/user/my.p12'), "password"
end
def pkcs12(p12_contents, password)
default_options[:p12] = p12_contents
default_options[:p12_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
read_timeout(t)
click to toggle source
Allows setting a default read_timeout for all
HTTP calls in seconds
class Foo
include HTTParty
read_timeout 10
end
def read_timeout(t)
raise ArgumentError, 'read_timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
default_options[:read_timeout] = t
end
ssl_ca_file(path)
click to toggle source
Allows setting an OpenSSL certificate authority file. The file should
contain one or more certificates in PEM format.
Setting this option enables certificate verification. All certificates
along a chain must be available in ssl_ca_file or ssl_ca_path for
verification to succeed.
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).
Setting this option enables certificate verification. All certificates
along a chain must be available in ssl_ca_file or ssl_ca_path for
verification to succeed.
class Foo
include HTTParty
ssl_ca_path '/etc/ssl/certs/'
end
def ssl_ca_path(path)
default_options[:ssl_ca_path] = path
end
ssl_version(version)
click to toggle source
Allows setting of SSL version to use. This only works in Ruby 1.9+. You can
get a list of valid versions from OpenSSL::SSL::SSLContext::METHODS.
class Foo
include HTTParty
ssl_version :SSLv3
end
def ssl_version(version)
default_options[:ssl_version] = version
end